agentic-qe 1.0.1 → 1.0.3

package/.claude/agents/qe-fleet-commander.md

@@ -13,17 +13,8 @@ capabilities:
   - fault-tolerance
   - scaling-orchestration
   - performance-monitoring
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Fleet Commander: Initializing fleet coordination'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/fleet/topology'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/fleet/agents/active'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/fleet/coordination/results' --value '${COORDINATION_RESULTS}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/fleet/metrics/performance' --value '${FLEET_METRICS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/fleet/config/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "2.0.0"
   max_agents: 50
@@ -139,18 +130,29 @@ await fleetCommander.rebalanceLoad(rebalancingStrategy);
 ## Integration Points
 
 ### Memory Coordination
-```bash
-# Store fleet topology and configuration
-npx claude-flow@alpha memory store --key "aqe/fleet/topology" --value '{"mode":"hierarchical","agents":50}'
+```typescript
+// Store fleet topology and configuration
+await this.memoryStore.store('aqe/fleet/topology', {
+  mode: 'hierarchical',
+  agents: 50
+}, {
+  partition: 'coordination'
+});
 
-# Store agent lifecycle status
-npx claude-flow@alpha memory store --key "aqe/fleet/agents/active" --value "${ACTIVE_AGENTS_JSON}"
+// Store agent lifecycle status
+await this.memoryStore.store('aqe/fleet/agents/active', activeAgentsJson, {
+  partition: 'coordination'
+});
 
-# Store resource allocation matrix
-npx claude-flow@alpha memory store --key "aqe/fleet/resources/allocation" --value "${RESOURCE_MATRIX}"
+// Store resource allocation matrix
+await this.memoryStore.store('aqe/fleet/resources/allocation', resourceMatrix, {
+  partition: 'coordination'
+});
 
-# Store coordination metrics
-npx claude-flow@alpha memory store --key "aqe/fleet/metrics/coordination" --value "${COORDINATION_METRICS}"
+// Store coordination metrics
+await this.memoryStore.store('aqe/fleet/metrics/coordination', coordinationMetrics, {
+  partition: 'coordination'
+});
 ```
 
 ### EventBus Integration
@@ -184,6 +186,53 @@ eventBus.publish('fleet:topology-changed', {
 - **QE Performance Tester**: Orchestrates performance testing workflows
 - **QE Security Scanner**: Coordinates security scanning tasks
 
+## Coordination Protocol
+
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies, 100-500x faster).
+
+**Automatic Lifecycle Hooks:**
+```typescript
+// Automatically called by BaseAgent
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Load fleet topology and active agents
+  const topology = await this.memoryStore.retrieve('aqe/fleet/topology');
+  const activeAgents = await this.memoryStore.retrieve('aqe/fleet/agents/active');
+
+  this.logger.info('Fleet coordination initialized', {
+    topology: topology?.mode || 'hierarchical',
+    activeAgents: activeAgents?.length || 0,
+    maxAgents: 50
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store coordination results and fleet metrics
+  await this.memoryStore.store('aqe/fleet/coordination/results', data.result.coordinationOutcomes);
+  await this.memoryStore.store('aqe/fleet/metrics/performance', data.result.fleetMetrics);
+  await this.memoryStore.store('aqe/fleet/agents/active', data.result.activeAgents);
+
+  // Emit fleet coordination event
+  this.eventBus.emit('fleet-commander:coordinated', {
+    agentsOrchestrated: data.result.activeAgents.length,
+    throughput: data.result.fleetMetrics.throughput,
+    efficiency: data.result.fleetMetrics.efficiency
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'fleet-orchestration',
+  context: {
+    requiredVars: ['FLEET_MODE', 'MAX_AGENTS'],
+    minMemoryMB: 2048,
+    requiredKeys: ['aqe/fleet/topology']
+  }
+});
+```
+
 ## Memory Keys
 
 ### Input Keys
@@ -210,38 +259,46 @@ eventBus.publish('fleet:topology-changed', {
 ## Coordination Protocol
 
 ### Swarm Integration
-```bash
-# Initialize fleet with hierarchical topology
-npx claude-flow@alpha swarm init \
-  --topology "hierarchical" \
-  --max-agents 50 \
-  --coordinator "qe-fleet-commander"
-
-# Spawn specialized agent pool
-npx claude-flow@alpha agent spawn \
-  --type "test-executor" \
-  --pool-size 10 \
-  --priority "critical"
-
-# Orchestrate distributed testing workflow
-npx claude-flow@alpha task orchestrate \
-  --task "Execute 5000 tests across frameworks" \
-  --agents "test-executor:10,coverage-analyzer:3" \
-  --strategy "hierarchical-parallel"
+```typescript
+// Initialize fleet with hierarchical topology
+await this.swarmManager.initialize({
+  topology: 'hierarchical',
+  maxAgents: 50,
+  coordinator: 'qe-fleet-commander'
+});
+
+// Spawn specialized agent pool via EventBus
+this.eventBus.emit('fleet:spawn-pool', {
+  type: 'test-executor',
+  poolSize: 10,
+  priority: 'critical'
+});
+
+// Orchestrate distributed testing workflow
+await this.taskManager.orchestrate({
+  task: 'Execute 5000 tests across frameworks',
+  agents: {
+    'test-executor': 10,
+    'coverage-analyzer': 3
+  },
+  strategy: 'hierarchical-parallel'
+});
 ```
 
 ### Neural Pattern Training
-```bash
-# Train fleet coordination patterns
-npx claude-flow@alpha neural train \
-  --pattern-type "fleet-coordination" \
-  --training-data "coordination-history" \
-  --optimization "sublinear"
-
-# Predict optimal agent allocation
-npx claude-flow@alpha neural predict \
-  --model-id "fleet-allocation-model" \
-  --input "${WORKLOAD_ANALYSIS}"
+```typescript
+// Train fleet coordination patterns
+await this.neuralManager.trainPattern({
+  patternType: 'fleet-coordination',
+  trainingData: coordinationHistory,
+  optimization: 'sublinear'
+});
+
+// Predict optimal agent allocation
+const allocation = await this.neuralManager.predict({
+  modelId: 'fleet-allocation-model',
+  input: workloadAnalysis
+});
 ```
 
 ## Hierarchical Coordination Patterns

package/.claude/agents/qe-performance-tester.md

@@ -53,15 +53,8 @@ workflows:
   - regression_detection
   - reporting
   - optimization_recommendations
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Starting performance testing'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/performance/baselines'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/performance/results' --value '${PERF_RESULTS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/performance/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 description: "Multi-tool performance testing with load orchestration, bottleneck detection, and SLA validation"
 ---
 
@@ -93,11 +86,18 @@ description: "Multi-tool performance testing with load orchestration, bottleneck
 ## Workflow Orchestration
 
 ### Pre-Execution Phase
-```bash
-# Initialize coordination
-npx claude-flow@alpha hooks pre-task --description "Performance testing workflow"
-npx claude-flow@alpha memory retrieve --key "aqe/performance/baselines"
-npx claude-flow@alpha memory retrieve --key "aqe/test-plan/requirements"
+```typescript
+// Initialize coordination via native hooks
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Load baselines and requirements
+  const baselines = await this.memoryStore.retrieve('aqe/performance/baselines');
+  const requirements = await this.memoryStore.retrieve('aqe/test-plan/requirements');
+
+  this.logger.info('Performance testing workflow initialized', {
+    hasBaselines: !!baselines,
+    requirements: requirements?.performance || {}
+  });
+}
 ```
 
 ### Test Planning & Baseline Establishment
@@ -145,12 +145,25 @@ gatling.sh -s LoadTestSimulation -rf results/
    - Provide optimization recommendations
 
 ### Post-Execution Coordination
-```bash
-# Store results and notify other agents
-npx claude-flow@alpha memory store --key "aqe/performance/results" --value "$(cat results.json)"
-npx claude-flow@alpha memory store --key "aqe/performance/regressions" --value "$(cat regressions.json)"
-npx claude-flow@alpha hooks notify --message "Performance testing completed with $(cat summary.txt)"
-npx claude-flow@alpha hooks post-task --task-id "performance-testing"
+```typescript
+// Store results and notify other agents via native hooks
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store performance results
+  await this.memoryStore.store('aqe/performance/results', data.result.metrics, {
+    partition: 'coordination'
+  });
+
+  await this.memoryStore.store('aqe/performance/regressions', data.result.regressions, {
+    partition: 'coordination'
+  });
+
+  // Notify other agents via EventBus
+  this.eventBus.emit('performance:completed', {
+    summary: data.result.summary,
+    metrics: data.result.metrics,
+    regressions: data.result.regressions.length
+  });
+}
 ```
 
 ## Tool Integration
@@ -223,37 +236,77 @@ class LoadTestSimulation extends Simulation {
 }
 ```
 
+## Coordination Protocol
+
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies, 100-500x faster).
+
+**Automatic Lifecycle Hooks:**
+```typescript
+// Automatically called by BaseAgent
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Load performance baselines and thresholds
+  const baselines = await this.memoryStore.retrieve('aqe/performance/baselines');
+  const thresholds = await this.memoryStore.retrieve('aqe/performance/thresholds');
+
+  this.logger.info('Performance testing initialized', {
+    hasBaselines: !!baselines,
+    thresholds: thresholds?.response_time?.p95 || 500
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store performance test results
+  await this.memoryStore.store('aqe/performance/results', data.result.metrics);
+  await this.memoryStore.store('aqe/performance/regressions', data.result.regressions);
+
+  // Emit performance test completion
+  this.eventBus.emit('performance-tester:completed', {
+    p95Latency: data.result.metrics.latency.p95,
+    throughput: data.result.metrics.throughput,
+    regressions: data.result.regressions.length
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'performance-testing',
+  context: {
+    requiredVars: ['TARGET_URL', 'LOAD_PATTERN'],
+    minMemoryMB: 1024,
+    requiredKeys: ['aqe/performance/baselines']
+  }
+});
+```
+
 ## Memory Management
 
 ### Baseline Storage
-```bash
-# Store performance baselines
-npx claude-flow@alpha memory store --key "aqe/performance/baselines" --value '{
-  "api_response_time_p95": 200,
-  "page_load_time_p95": 2000,
-  "throughput_rps": 1000,
-  "error_rate_threshold": 0.01
-}'
+```typescript
+// Store performance baselines via memory
+await this.memoryStore.store('aqe/performance/baselines', {
+  api_response_time_p95: 200,
+  page_load_time_p95: 2000,
+  throughput_rps: 1000,
+  error_rate_threshold: 0.01
+}, {
+  partition: 'coordination',
+  ttl: 86400 // 24 hours
+});
 ```
 
 ### Threshold Configuration
-```bash
-# Configure performance thresholds
-npx claude-flow@alpha memory store --key "aqe/performance/thresholds" --value '{
-  "response_time": {
-    "p50": 100,
-    "p95": 500,
-    "p99": 1000
-  },
-  "throughput": {
-    "min_rps": 100,
-    "target_rps": 1000
-  },
-  "availability": {
-    "uptime_percentage": 99.9,
-    "error_rate_max": 0.01
-  }
-}'
+```typescript
+// Configure performance thresholds via memory
+await this.memoryStore.store('aqe/performance/thresholds', {
+  response_time: { p50: 100, p95: 500, p99: 1000 },
+  throughput: { min_rps: 100, target_rps: 1000 },
+  availability: { uptime_percentage: 99.9, error_rate_max: 0.01 }
+}, {
+  partition: 'coordination'
+});
 ```
 
 ## Agent Coordination

package/.claude/agents/qe-production-intelligence.md

@@ -12,17 +12,8 @@ capabilities:
   - feature-usage-analytics
   - error-pattern-mining
   - user-journey-reconstruction
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Analyzing production intelligence'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/production/incidents'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/production/rum-data'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/production/test-scenarios' --value '${SCENARIOS}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/production/insights' --value '${INSIGHTS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/production/updated'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "1.0.0"
   stakeholders: ["Engineering", "QA", "SRE", "Product", "Customer Success"]
@@ -1070,6 +1061,52 @@ describe('Real User Journey: Successful Purchase with Coupon', () => {
 - **qe-fleet-commander**: Orchestrates production intelligence workflow
 - **qe-deployment-readiness**: Uses production insights for risk assessment
 
+## Coordination Protocol
+
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies, 100-500x faster).
+
+**Automatic Lifecycle Hooks:**
+```typescript
+// Automatically called by BaseAgent
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Load production incidents and RUM data
+  const incidents = await this.memoryStore.retrieve('aqe/production/incidents');
+  const rumData = await this.memoryStore.retrieve('aqe/production/rum-data');
+
+  this.logger.info('Production intelligence analysis started', {
+    recentIncidents: incidents?.length || 0,
+    rumSessions: rumData?.totalSessions || 0
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store generated test scenarios and insights
+  await this.memoryStore.store('aqe/production/test-scenarios', data.result.scenarios);
+  await this.memoryStore.store('aqe/production/insights', data.result.insights);
+  await this.memoryStore.store('aqe/production/anomalies', data.result.anomalies);
+
+  // Emit production intelligence event
+  this.eventBus.emit('production-intelligence:analyzed', {
+    scenariosGenerated: data.result.scenarios.length,
+    anomaliesDetected: data.result.anomalies.length,
+    highPriorityInsights: data.result.insights.filter(i => i.priority === 'HIGH').length
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'production-analysis',
+  context: {
+    requiredVars: ['PROD_ENV', 'MONITORING_PLATFORM'],
+    minMemoryMB: 1024,
+    requiredKeys: ['aqe/production/incidents', 'aqe/production/rum-data']
+  }
+});
+```
+
 ## Memory Keys
 
 ### Input Keys

package/.claude/agents/qe-quality-gate.md

@@ -14,15 +14,8 @@ capabilities:
   - decision-trees
   - threshold-management
   - automated-decisions
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Starting quality gate validation'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/quality/thresholds'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/quality/decisions' --value '${GATE_DECISIONS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/quality/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   decision_tree_capabilities: true
   temporal_prediction: enabled
@@ -58,6 +51,164 @@ integration_points:
 - Risk-based override mechanisms with audit trails
 - Real-time policy compliance monitoring
 
+## Coordination Protocol
+
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies, 100-500x faster).
+
+**Automatic Lifecycle Hooks:**
+```typescript
+// Called automatically by BaseAgent
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Load quality thresholds from memory
+  const thresholds = await this.memoryStore.retrieve('aqe/quality/thresholds', {
+    partition: 'configuration'
+  });
+
+  // Retrieve decision context
+  const context = await this.memoryStore.retrieve('aqe/context', {
+    partition: 'coordination'
+  });
+
+  // Verify environment for quality gate execution
+  const verification = await this.hookManager.executePreTaskVerification({
+    task: 'quality-gate-evaluation',
+    context: {
+      requiredVars: ['NODE_ENV', 'QUALITY_PROFILE'],
+      minMemoryMB: 512,
+      requiredModules: ['jest', 'eslint']
+    }
+  });
+
+  // Emit quality gate starting event
+  this.eventBus.emit('quality-gate:starting', {
+    agentId: this.agentId,
+    thresholds: thresholds,
+    context: context
+  });
+
+  this.logger.info('Quality gate validation starting', {
+    thresholds,
+    verification: verification.passed
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store quality gate decisions in swarm memory
+  await this.memoryStore.store('aqe/quality/decisions', data.result, {
+    partition: 'decisions',
+    ttl: 86400 // 24 hours
+  });
+
+  // Store decision metrics for trend analysis
+  await this.memoryStore.store('aqe/quality/metrics', {
+    timestamp: Date.now(),
+    decision: data.result.decision,
+    score: data.result.score,
+    riskLevel: data.result.riskLevel,
+    policyViolations: data.result.policyViolations
+  }, {
+    partition: 'metrics',
+    ttl: 604800 // 7 days
+  });
+
+  // Emit completion event with decision outcome
+  this.eventBus.emit('quality-gate:completed', {
+    agentId: this.agentId,
+    decision: data.result.decision,
+    score: data.result.score,
+    goPassed: data.result.decision === 'GO'
+  });
+
+  // Validate quality gate results
+  const validation = await this.hookManager.executePostTaskValidation({
+    task: 'quality-gate-evaluation',
+    result: {
+      output: data.result,
+      coverage: data.result.coverageScore,
+      metrics: {
+        qualityScore: data.result.score,
+        riskLevel: data.result.riskLevel
+      }
+    }
+  });
+
+  this.logger.info('Quality gate evaluation completed', {
+    decision: data.result.decision,
+    score: data.result.score,
+    validated: validation.passed
+  });
+}
+
+protected async onTaskError(data: { assignment: TaskAssignment; error: Error }): Promise<void> {
+  // Store error for fleet analysis
+  await this.memoryStore.store(`aqe/errors/${data.assignment.task.id}`, {
+    error: data.error.message,
+    timestamp: Date.now(),
+    agent: this.agentId,
+    taskType: 'quality-gate-evaluation'
+  }, {
+    partition: 'errors',
+    ttl: 604800 // 7 days
+  });
+
+  // Emit error event for fleet coordination
+  this.eventBus.emit('quality-gate:error', {
+    agentId: this.agentId,
+    error: data.error.message,
+    taskId: data.assignment.task.id
+  });
+
+  this.logger.error('Quality gate evaluation failed', {
+    error: data.error.message,
+    stack: data.error.stack
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+// Use VerificationHookManager for comprehensive validation
+const hookManager = new VerificationHookManager(this.memoryStore);
+
+// Pre-task verification with environment checks
+const verification = await hookManager.executePreTaskVerification({
+  task: 'quality-gate-evaluation',
+  context: {
+    requiredVars: ['NODE_ENV', 'QUALITY_PROFILE', 'THRESHOLD_CONFIG'],
+    minMemoryMB: 512,
+    requiredModules: ['jest', 'eslint', '@typescript-eslint/parser']
+  }
+});
+
+// Post-task validation with result verification
+const validation = await hookManager.executePostTaskValidation({
+  task: 'quality-gate-evaluation',
+  result: {
+    output: gateDecision,
+    coverage: coverageScore,
+    metrics: {
+      qualityScore: qualityScore,
+      riskLevel: riskLevel,
+      policyCompliance: complianceScore
+    }
+  }
+});
+
+// Pre-edit verification before modifying quality configurations
+const editCheck = await hookManager.executePreEditVerification({
+  filePath: 'config/quality-thresholds.json',
+  operation: 'write',
+  content: JSON.stringify(newThresholds)
+});
+
+// Session finalization with quality gate audit export
+const finalization = await hookManager.executeSessionEndFinalization({
+  sessionId: 'quality-gate-v2.0.0',
+  exportMetrics: true,
+  exportArtifacts: true
+});
+```
+
 ## Decision Workflow
 
 ### Phase 1: Context Assessment
@@ -249,25 +400,6 @@ agentic-qe agent status --name qe-quality-gate
 agentic-qe agent history qe-quality-gate --decisions --limit 50
 ```
 
-## Coordination Hooks
-
-### Pre-Task Hooks
-```bash
-# Validate quality thresholds before evaluation
-npx claude-flow@alpha hooks pre-task --agent qe-quality-gate --action validate_thresholds
-
-# Load decision context
-npx claude-flow@alpha hooks pre-task --agent qe-quality-gate --action load_context
-```
-
-### Post-Task Hooks
-```bash
-# Update quality metrics after decision
-npx claude-flow@alpha hooks post-task --agent qe-quality-gate --action update_metrics
-
-# Store decision outcomes
-npx claude-flow@alpha hooks post-task --agent qe-quality-gate --action store_outcomes
-```
 
 ## Fleet Integration