agentic-qe 3.8.7 → 3.8.8

package/assets/agents/v3/subagents/qe-tdd-red.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 RED Patterns BEFORE Writing Tests
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "tdd/red/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "tdd/red/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Test Creation)
 
 **1. Store RED Phase Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "tdd-red/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-tdd-red",
-    taskType: "failing-test-creation",
-    reward: <calculated_reward>,
-    outcome: {
-      testsWritten: <count>,
-      assertionsSpecified: <count>,
-      failureVerified: <boolean>,
-      structurePattern: "<pattern-used>",
-      namingConvention: "<convention-applied>"
-    },
-    patterns: {
-      effectiveStructures: ["<structures>"],
-      assertionPatterns: ["<patterns>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "tdd-red/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store RED Phase Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/tdd-red/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<red phase pattern description>",
-    confidence: <0.0-1.0>,
-    type: "tdd-red",
-    metadata: {
-      behaviorType: "<type>",
-      testStructure: "<structure>",
-      assertionCount: <count>
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/tdd-red/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Signal to Parent Agent:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "red-phase-complete",
-  priority: "p1",
-  payload: {
-    testsCreated: [...],
-    failureVerified: true,
-    readyForGreen: true
-  }
-})
+```bash
+aqe task submit \
+  "red-phase-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/agents/v3/subagents/qe-tdd-refactor.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 Refactoring Patterns BEFORE Analysis
 
-```typescript
-mcp__agentic-qe__memory_retrieve({
-  key: "tdd/refactor/patterns",
-  namespace: "learning"
-})
+```bash
+aqe memory get --key "tdd/refactor/patterns" --namespace "learning" --json
 ```
 
 ### Required Learning Actions (Call AFTER Refactoring)
 
 **1. Store REFACTOR Phase Experience:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "tdd-refactor/outcome-{timestamp}",
-  namespace: "learning",
-  value: {
-    agentId: "qe-tdd-refactor",
-    taskType: "code-refactoring",
-    reward: <calculated_reward>,
-    outcome: {
-      smellsDetected: <count>,
-      smellsFixed: <count>,
-      refactoringsApplied: <count>,
-      linesRemoved: <count>,
-      testsRemainGreen: <boolean>
-    },
-    patterns: {
-      effectiveRefactorings: ["<patterns>"],
-      commonSmells: ["<smells>"]
-    }
-  }
-})
+```bash
+aqe memory store \
+  --key "tdd-refactor/outcome-{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Store Refactoring Pattern:**
-```typescript
-mcp__agentic-qe__memory_store({
-  key: "patterns/tdd-refactor/{timestamp}",
-  namespace: "learning",
-  value: {
-    pattern: "<refactoring pattern description>",
-    confidence: <0.0-1.0>,
-    type: "tdd-refactor",
-    metadata: {
-      smellType: "<smell>",
-      refactoringApplied: "<pattern>",
-      designImprovement: "<improvement>"
-    }
-  },
-  persist: true
-})
+```bash
+aqe memory store \
+  --key "patterns/tdd-refactor/{timestamp}" \
+  --namespace "learning" \
+  --value '{...}' \
+  --json
 ```
 
 **3. Signal to Parent Agent:**
-```typescript
-mcp__agentic-qe__task_submit({
-  type: "refactor-phase-complete",
-  priority: "p1",
-  payload: {
-    refactoringComplete: true,
-    testsGreen: true,
-    cycleComplete: true
-  }
-})
+```bash
+aqe task submit \
+  "refactor-phase-complete" \
+  --priority "p1" \
+  --payload '{...}' \
+  --json
 ```
 
 ### Reward Calculation Criteria (0-1 scale)

package/assets/skills/.validation/schemas/skill-eval.schema.json

@@ -362,27 +362,27 @@
         "store_patterns": {
           "type": "boolean",
           "default": true,
-          "description": "Store successful patterns via mcp__agentic-qe__memory_store"
+          "description": "Store successful patterns via aqe memory store"
         },
         "query_patterns": {
           "type": "boolean",
           "default": true,
-          "description": "Query existing patterns before running via mcp__agentic-qe__memory_query"
+          "description": "Query existing patterns before running via aqe memory search"
         },
         "track_outcomes": {
           "type": "boolean",
           "default": true,
-          "description": "Track test outcomes via mcp__agentic-qe__test_outcome_track"
+          "description": "Track test outcomes via aqe hooks post-task"
         },
         "share_learning": {
           "type": "boolean",
           "default": true,
-          "description": "Share learning with fleet via mcp__agentic-qe__memory_share"
+          "description": "Share learning with fleet via aqe memory share"
         },
         "update_quality_gate": {
           "type": "boolean",
           "default": true,
-          "description": "Update quality gate metrics via mcp__agentic-qe__quality_assess"
+          "description": "Update quality gate metrics via aqe quality"
         },
         "target_agents": {
           "type": "array",

package/assets/skills/.validation/skill-validation-mcp-integration.md

@@ -14,33 +14,22 @@ All skill validation components MUST use AQE MCP tool calls for shared learning.
 
 Skills MUST store successful validation patterns for future reference:
 
-```typescript
+```bash
 // After successful validation
-mcp__agentic-qe__memory_store({
-  key: `skill-validation-${skillName}-${timestamp}`,
-  value: {
-    skillName: string,
-    trustTier: number,
-    validationResult: ValidationResult,
-    model: string,
-    passRate: number,
-    patterns: LearnedPattern[]
-  },
-  namespace: "skill-validation"
-})
+aqe memory store \
+  --key "skill-validation-${skillName}-${timestamp}" \
+  --namespace "skill-validation" \
+  --value '{...}' \
+  --json
 ```
 
 ### 2. Pattern Query
 
 Before validation, query for existing patterns:
 
-```typescript
+```bash
 // Query learned patterns
-const existingPatterns = await mcp__agentic-qe__memory_query({
-  pattern: `skill-validation-${skillName}-*`,
-  namespace: "skill-validation",
-  limit: 10
-})
+const existingPatterns = await aqe memory search --pattern "*" --namespace "skill-validation" --limit 10 --json
 
 // Use patterns to inform validation expectations
 ```
@@ -49,57 +38,31 @@ const existingPatterns = await mcp__agentic-qe__memory_query({
 
 Track all validation outcomes for the learning feedback loop:
 
-```typescript
+```bash
 // Record validation outcome
-mcp__agentic-qe__test_outcome_track({
-  testId: `skill-${skillName}-${evalId}`,
-  generatedBy: agentId,
-  patternId: usedPatternId,
-  passed: boolean,
-  coverage: {
-    lines: number,
-    branches: number,
-    functions: number
-  },
-  executionTime: number,
-  flaky: false
-})
+aqe hooks post-task --json
 ```
 
 ### 4. Cross-Agent Learning Share
 
 Share validation insights with the learning coordinator:
 
-```typescript
+```bash
 // Share learning with fleet
-mcp__agentic-qe__memory_share({
-  sourceAgentId: currentAgentId,
-  targetAgentIds: ["qe-learning-coordinator", "qe-queen-coordinator"],
-  knowledgeDomain: "skill-validation",
-  data: {
-    skillName: string,
-    insights: ValidationInsight[],
-    recommendations: string[]
-  }
-})
+aqe memory share \
+  --from "unknown" \
+  --to "qe-learning-coordinator,qe-queen-coordinator" \
+  --domain "skill-validation" \
+  --content '{...}' --json
 ```
 
 ### 5. Quality Gate Integration
 
 Update skill quality scores via quality assessment:
 
-```typescript
+```bash
 // After validation completes
-mcp__agentic-qe__quality_assess({
-  target: `skill:${skillName}`,
-  metrics: {
-    passRate: number,
-    schemaCompliance: boolean,
-    validatorPassed: boolean,
-    evalSuiteScore: number
-  },
-  updateQualityScore: true
-})
+aqe quality --json
 ```
 
 ## Memory Namespace Structure
@@ -131,48 +94,36 @@ The `scripts/run-skill-eval.ts` evaluation runner MUST:
 3. **After evals**: Store patterns and share learning
 4. **On regression**: Alert via quality gate
 
-```typescript
+```bash
 // Evaluation runner pseudocode
 async function runSkillEval(skill: string, model: string) {
   // 1. Query existing patterns
-  const patterns = await mcp__agentic-qe__memory_query({
-    pattern: `skill-validation-${skill}-*`,
-    namespace: "skill-validation"
-  });
+  const patterns = await aqe memory search --pattern "*" --namespace "skill-validation" --json;
 
   // 2. Run evaluation test cases
   const results = await runTestCases(skill, model, patterns);
 
   // 3. Track outcomes
   for (const result of results) {
-    await mcp__agentic-qe__test_outcome_track({
-      testId: result.id,
-      passed: result.passed,
-      // ...
-    });
+    await aqe hooks post-task --json;
   }
 
   // 4. Store new patterns
-  await mcp__agentic-qe__memory_store({
-    key: `skill-validation-${skill}-${Date.now()}`,
-    value: { results, patterns: extractPatterns(results) },
-    namespace: "skill-validation"
-  });
+  await aqe memory store \
+  --key "skill-validation-${skill}-${Date.now()}" \
+  --namespace "skill-validation" \
+  --value '{...}' \
+  --json;
 
   // 5. Share learning
-  await mcp__agentic-qe__memory_share({
-    sourceAgentId: "eval-runner",
-    targetAgentIds: ["qe-learning-coordinator"],
-    knowledgeDomain: "skill-validation",
-    data: summarizeResults(results)
-  });
+  aqe memory share \
+    --from "eval-runner" \
+    --to "qe-learning-coordinator" \
+    --domain "skill-validation" \
+    --content '{"data": "summarized results"}' --json;
 
   // 6. Update quality gate
-  await mcp__agentic-qe__quality_assess({
-    target: `skill:${skill}`,
-    metrics: calculateMetrics(results),
-    updateQualityScore: true
-  });
+  await aqe quality --json;
 
   return results;
 }

package/assets/skills/agentic-quality-engineering/SKILL.md

@@ -124,34 +124,22 @@ aqe/coordination/*  - Cross-agent state
 
 ### Memory Operations (MCP Tools)
 
-**CRITICAL**: Always use `mcp__agentic-qe__memory_store` with `persist: true` for learnings.
+**CRITICAL**: Always use `aqe memory store` with `persist: true` for learnings.
 
 **1. Store data to persistent memory:**
-```javascript
+```bash
 // Store test plan decisions (persisted to .agentic-qe/memory.db)
-mcp__agentic-qe__memory_store({
-  key: "aqe/test-plan/pr-123",
-  namespace: "aqe/test-plan",
-  value: {
-    prNumber: 123,
-    riskLevel: "medium",
-    requiredCoverage: 85,
-    testTypes: ["unit", "integration"],
-    estimatedTime: 1800
-  },
-  persist: true,  // ⚠️ REQUIRED for cross-session persistence
-  ttl: 604800     // 7 days (0 = permanent)
-})
+aqe memory store \
+  --key "aqe/test-plan/pr-123" \
+  --namespace "aqe/test-plan" \
+  --value '{...}' \
+  --json
 ```
 
 **2. Retrieve prior learnings before task:**
-```javascript
+```bash
 // Query patterns before starting test generation
-const priorData = await mcp__agentic-qe__memory_retrieve({
-  key: "aqe/learning/patterns/test-generation/*",
-  namespace: "aqe/learning",
-  includeMetadata: true
-})
+const priorData = await aqe memory get --key "aqe/learning/patterns/test-generation/*" --namespace "aqe/learning" --json
 
 // Use patterns to guide current task
 if (priorData.success) {
@@ -160,56 +148,39 @@ if (priorData.success) {
 ```
 
 **3. Store coverage analysis results:**
-```javascript
-mcp__agentic-qe__memory_store({
-  key: "aqe/coverage/auth-module",
-  namespace: "aqe/coverage",
-  value: {
-    moduleId: "auth-module",
-    currentCoverage: 78,
-    gaps: ["error-handling", "edge-cases"],
-    suggestedTests: 12,
-    priority: "high"
-  },
-  persist: true,
-  ttl: 1209600  // 14 days
-})
+```bash
+aqe memory store \
+  --key "aqe/coverage/auth-module" \
+  --namespace "aqe/coverage" \
+  --value '{...}' \
+  --json
 ```
 
 ### Three-Phase Memory Protocol
 
 For coordinated multi-agent tasks, use the STATUS → PROGRESS → COMPLETE pattern:
 
-```javascript
+```bash
 // PHASE 1: STATUS - Task starting
-mcp__agentic-qe__memory_store({
-  key: "aqe/coordination/task-123/status",
-  namespace: "aqe/coordination",
-  value: { status: "running", agent: "qe-test-generator", startTime: Date.now() },
-  persist: true
-})
+aqe memory store \
+  --key "aqe/coordination/task-123/status" \
+  --namespace "aqe/coordination" \
+  --value '{...}' \
+  --json
 
 // PHASE 2: PROGRESS - Intermediate updates
-mcp__agentic-qe__memory_store({
-  key: "aqe/coordination/task-123/progress",
-  namespace: "aqe/coordination",
-  value: { progress: 50, action: "generating-unit-tests", testsGenerated: 25 },
-  persist: true
-})
+aqe memory store \
+  --key "aqe/coordination/task-123/progress" \
+  --namespace "aqe/coordination" \
+  --value '{...}' \
+  --json
 
 // PHASE 3: COMPLETE - Task finished
-mcp__agentic-qe__memory_store({
-  key: "aqe/coordination/task-123/complete",
-  namespace: "aqe/coordination",
-  value: {
-    status: "complete",
-    result: "success",
-    testsGenerated: 47,
-    coverageAchieved: 92.3,
-    duration: 15000
-  },
-  persist: true
-})
+aqe memory store \
+  --key "aqe/coordination/task-123/complete" \
+  --namespace "aqe/coordination" \
+  --value '{...}' \
+  --json
 ```
 
 ### Blackboard Events

package/assets/skills/pair-programming/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: Pair Programming
-description: "Use when pair programming with AI assistance, practicing TDD with a navigator, debugging collaboratively, refactoring with real-time verification, or running learning sessions with continuous code review and quality monitoring."
+name: "pair-programming"
+description: "Provides AI navigator for pair programming sessions with real-time code review, TDD guidance, and quality monitoring. Use when pair programming with AI assistance, practicing TDD with a navigator, debugging collaboratively, or refactoring with real-time verification."
 ---
 
 # Pair Programming

package/assets/skills/performance-testing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: performance-testing
-description: "Test application performance, scalability, and resilience. Use when planning load testing, stress testing, or optimizing system performance."
+description: "Profiles application performance under load using k6, Artillery, or JMeter to measure latency, throughput, and error rates. Use when planning load tests, stress tests, soak tests, benchmarking APIs, or identifying performance bottlenecks."
 category: specialized-testing
 priority: high
 tokenEstimate: 1100

package/assets/skills/qcsd-cicd-swarm/steps/01-flag-detection.md

@@ -14,8 +14,8 @@
 Retrieve the most recent Development phase signals from memory.
 
 **MCP Method:**
-```javascript
-mcp__agentic-qe__memory_query({ pattern: "qcsd-development-*", namespace: "qcsd-development", limit: 1 })
+```bash
+aqe memory search --pattern "qcsd-development-*" --namespace "qcsd-development" --limit 1 --json
 ```
 
 ### Flag Detection (Check ALL SIX)

package/assets/skills/qcsd-cicd-swarm/steps/07-learning-persistence.md

@@ -9,12 +9,12 @@
 
 Store verification findings to memory:
 
-```javascript
-mcp__agentic-qe__memory_store({
-  key: `qcsd-cicd-${buildId}-${Date.now()}`,
-  namespace: "qcsd-cicd",
-  value: { recommendation, qualityGateStatus, regressionCount, flakyRate, flags, timestamp }
-})
+```bash
+aqe memory store \
+  --key "qcsd-cicd-${buildId}-${Date.now()}" \
+  --namespace "qcsd-cicd" \
+  --value '{...}' \
+  --json
 ```
 
 Save persistence record to `${OUTPUT_FOLDER}/11-learning-persistence.json`.

package/assets/skills/qcsd-development-swarm/steps/01-flag-detection.md

@@ -8,8 +8,8 @@
 ## Instructions
 
 ### Step 0: Retrieve Refinement Phase Signals
-```javascript
-mcp__agentic-qe__memory_query({ pattern: "qcsd-refinement-*", namespace: "qcsd-refinement", limit: 1 })
+```bash
+aqe memory search --pattern "qcsd-refinement-*" --namespace "qcsd-refinement" --limit 1 --json
 ```
 
 ### Flag Detection (Check ALL SIX)

package/assets/skills/qcsd-development-swarm/steps/07-learning-persistence.md

@@ -8,12 +8,12 @@
 ### ALWAYS RUN.
 
 Store development findings:
-```javascript
-mcp__agentic-qe__memory_store({
-  key: `qcsd-development-${storyId}-${Date.now()}`,
-  namespace: "qcsd-development",
-  value: { recommendation, tddScore, complexityScore, coveragePercent, flags, timestamp }
-})
+```bash
+aqe memory store \
+  --key "qcsd-development-${storyId}-${Date.now()}" \
+  --namespace "qcsd-development" \
+  --value '{...}' \
+  --json
 ```
 
 Save to `${OUTPUT_FOLDER}/11-learning-persistence.json`.

package/assets/skills/qcsd-ideation-swarm/steps/07-learning-persistence.md

@@ -8,12 +8,12 @@
 ### ALWAYS RUN.
 
 Store ideation findings:
-```javascript
-mcp__agentic-qe__memory_store({
-  key: `qcsd-ideation-${epicId}-${Date.now()}`,
-  namespace: "qcsd-ideation",
-  value: { recommendation, testabilityScore, riskCount, qualityCriteriaCount, flags, timestamp }
-})
+```bash
+aqe memory store \
+  --key "qcsd-ideation-${epicId}-${Date.now()}" \
+  --namespace "qcsd-ideation" \
+  --value '{...}' \
+  --json
 ```
 
 Save to `${OUTPUT_FOLDER}/11-learning-persistence.json`.