agentic-qe 1.0.1 → 1.0.2

package/.claude/agents/qe-regression-risk-analyzer.md

@@ -12,17 +12,8 @@ capabilities:
   - historical-pattern-learning
   - blast-radius-calculation
   - ci-optimization
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Analyzing regression risk'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/regression/history'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/code-changes/current'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/regression/risk-score' --value '${RISK_SCORE}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/regression/test-selection' --value '${SELECTED_TESTS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/regression/file-tracked'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "1.0.0"
   stakeholders: ["Engineering", "QA", "DevOps"]
@@ -745,6 +736,57 @@ ci_optimization:
     avg_reduction: "96.3%"
 ```
 
+## Coordination Protocol
+
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies, 100-500x faster).
+
+**Automatic Lifecycle Hooks:**
+```typescript
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Retrieve regression history
+  const history = await this.memoryStore.retrieve('aqe/regression/history', {
+    partition: 'historical_data'
+  });
+
+  // Retrieve current code changes
+  const codeChanges = await this.memoryStore.retrieve('aqe/code-changes/current', {
+    partition: 'code_analysis'
+  });
+
+  this.eventBus.emit('regression-analyzer:starting', {
+    agentId: this.agentId,
+    changesDetected: codeChanges?.files?.length || 0
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store risk score
+  await this.memoryStore.store('aqe/regression/risk-score', data.result.riskScore, {
+    partition: 'risk_analysis'
+  });
+
+  // Store selected tests
+  await this.memoryStore.store('aqe/regression/test-selection', data.result.selectedTests, {
+    partition: 'test_selection'
+  });
+
+  this.eventBus.emit('regression-analyzer:completed', {
+    agentId: this.agentId,
+    riskScore: data.result.riskScore,
+    testsSelected: data.result.selectedTests.length
+  });
+}
+```
+
+**Advanced Verification:**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'regression-risk-analysis',
+  context: { requiredVars: ['GIT_COMMIT'], minMemoryMB: 256 }
+});
+```
+
 ## Integration Points
 
 ### Upstream Dependencies

package/.claude/agents/qe-requirements-validator.md

@@ -12,17 +12,8 @@ capabilities:
   - traceability-mapping
   - edge-case-identification
   - requirement-completeness-check
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Validating requirements testability'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/requirements/validated'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/project-context'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/requirements/validation-report' --value '${VALIDATION_RESULTS}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/bdd-scenarios/generated' --value '${BDD_SCENARIOS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/requirements/updated'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "1.0.0"
   stakeholders: ["Product", "Engineering", "QA", "Business Analysts"]
@@ -260,6 +251,52 @@ Validates that requirements cover all necessary aspects using the **5 Ws framewo
 - **Why**: Business value and user needs articulated?
 - **How**: Technical approach and constraints documented?
 
+## Coordination Protocol
+
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies).
+
+**Automatic Lifecycle Hooks:**
+- `onPreTask()` - Called before task execution
+- `onPostTask()` - Called after task completion
+- `onTaskError()` - Called on task failure
+
+**Memory Integration:**
+```typescript
+// Store validation results
+await this.memoryStore.store('aqe/requirements/validation-report', validationResults, {
+  partition: 'validation',
+  ttl: 86400 // 24 hours
+});
+
+// Retrieve validated requirements
+const validated = await this.memoryStore.retrieve('aqe/requirements/validated', {
+  partition: 'requirements'
+});
+
+// Store BDD scenarios
+await this.memoryStore.store('aqe/bdd-scenarios/generated', bddScenarios, {
+  partition: 'scenarios'
+});
+```
+
+**Event Bus Integration:**
+```typescript
+// Emit events for coordination
+this.eventBus.emit('requirements-validator:completed', {
+  agentId: this.agentId,
+  requirementsValidated: count,
+  scenariosGenerated: scenarioCount
+});
+
+// Listen for fleet events
+this.registerEventHandler({
+  eventType: 'requirements:validation-requested',
+  handler: async (event) => {
+    await this.validateRequirements(event.requirements);
+  }
+});
+```
+
 ## Integration Points
 
 ### Upstream Dependencies

package/.claude/agents/qe-security-scanner.md

@@ -58,15 +58,8 @@ workflows:
   - security_testing
   - reporting
   - remediation_tracking
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Starting security scanning'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/security/policies'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/security/vulnerabilities' --value '${SCAN_RESULTS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/security/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 description: "Multi-layer security scanning with SAST/DAST, vulnerability detection, and compliance validation"
 ---
 
@@ -100,11 +93,173 @@ description: "Multi-layer security scanning with SAST/DAST, vulnerability detect
 ## Workflow Orchestration
 
 ### Pre-Execution Phase
-```bash
-# Initialize security scanning coordination
-npx claude-flow@alpha hooks pre-task --description "Security scanning workflow"
-npx claude-flow@alpha memory retrieve --key "aqe/security/policies"
-npx claude-flow@alpha memory retrieve --key "aqe/test-plan/security-requirements"
+
+**Native TypeScript Hooks:**
+```typescript
+// Called automatically by BaseAgent
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Retrieve security policies from memory
+  const policies = await this.memoryStore.retrieve('aqe/security/policies', {
+    partition: 'configuration'
+  });
+
+  // Retrieve security requirements
+  const requirements = await this.memoryStore.retrieve('aqe/test-plan/security-requirements', {
+    partition: 'test_plans'
+  });
+
+  // Retrieve security baseline for comparison
+  const baseline = await this.memoryStore.retrieve('aqe/security/baselines', {
+    partition: 'baselines'
+  });
+
+  // Verify environment for security scanning
+  const verification = await this.hookManager.executePreTaskVerification({
+    task: 'security-scan',
+    context: {
+      requiredVars: ['TARGET_URL', 'SCAN_TYPE', 'SECURITY_PROFILE'],
+      minMemoryMB: 1024,
+      requiredModules: ['snyk', 'eslint-plugin-security']
+    }
+  });
+
+  // Emit security scanning started event
+  this.eventBus.emit('security-scanner:starting', {
+    agentId: this.agentId,
+    policiesCount: policies?.length || 0,
+    scanType: data.assignment.task.metadata.scanType,
+    targetUrl: data.assignment.task.metadata.targetUrl
+  });
+
+  this.logger.info('Security scanning starting', {
+    policies: policies?.length || 0,
+    requirements,
+    verification: verification.passed
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store security vulnerabilities in swarm memory
+  await this.memoryStore.store('aqe/security/vulnerabilities', data.result.vulnerabilities, {
+    partition: 'scan_results',
+    ttl: 604800 // 7 days
+  });
+
+  // Store compliance status
+  await this.memoryStore.store('aqe/security/compliance', data.result.compliance, {
+    partition: 'compliance',
+    ttl: 2592000 // 30 days
+  });
+
+  // Store security metrics for trend analysis
+  await this.memoryStore.store('aqe/security/metrics', {
+    timestamp: Date.now(),
+    vulnerabilitiesFound: data.result.vulnerabilities.length,
+    criticalCount: data.result.vulnerabilities.filter(v => v.severity === 'critical').length,
+    highCount: data.result.vulnerabilities.filter(v => v.severity === 'high').length,
+    complianceScore: data.result.compliance.score
+  }, {
+    partition: 'metrics',
+    ttl: 604800 // 7 days
+  });
+
+  // Emit completion event with scan results
+  this.eventBus.emit('security-scanner:completed', {
+    agentId: this.agentId,
+    vulnerabilitiesFound: data.result.vulnerabilities.length,
+    complianceScore: data.result.compliance.score,
+    criticalVulnerabilities: data.result.vulnerabilities.filter(v => v.severity === 'critical').length
+  });
+
+  // Validate security scan results
+  const validation = await this.hookManager.executePostTaskValidation({
+    task: 'security-scan',
+    result: {
+      output: data.result,
+      coverage: data.result.coverage,
+      metrics: {
+        vulnerabilitiesFound: data.result.vulnerabilities.length,
+        complianceScore: data.result.compliance.score
+      }
+    }
+  });
+
+  this.logger.info('Security scanning completed', {
+    vulnerabilities: data.result.vulnerabilities.length,
+    compliance: data.result.compliance.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: 'security-scan',
+    scanType: data.assignment.task.metadata.scanType
+  }, {
+    partition: 'errors',
+    ttl: 604800 // 7 days
+  });
+
+  // Emit error event for fleet coordination
+  this.eventBus.emit('security-scanner:error', {
+    agentId: this.agentId,
+    error: data.error.message,
+    taskId: data.assignment.task.id
+  });
+
+  this.logger.error('Security scanning 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 security tool checks
+const verification = await hookManager.executePreTaskVerification({
+  task: 'security-scan',
+  context: {
+    requiredVars: ['TARGET_URL', 'SCAN_TYPE', 'API_KEY'],
+    minMemoryMB: 1024,
+    requiredModules: ['snyk', '@snyk/cli', 'eslint-plugin-security', 'semgrep']
+  }
+});
+
+// Post-task validation with vulnerability threshold checks
+const validation = await hookManager.executePostTaskValidation({
+  task: 'security-scan',
+  result: {
+    output: scanResults,
+    coverage: coverageData,
+    metrics: {
+      criticalVulnerabilities: 0,
+      highVulnerabilities: 2,
+      complianceScore: 0.95
+    }
+  }
+});
+
+// Pre-edit verification before updating security policies
+const editCheck = await hookManager.executePreEditVerification({
+  filePath: 'config/security-policies.json',
+  operation: 'write',
+  content: JSON.stringify(newPolicies)
+});
+
+// Session finalization with security audit export
+const finalization = await hookManager.executeSessionEndFinalization({
+  sessionId: 'security-scan-v2.0.0',
+  exportMetrics: true,
+  exportArtifacts: true
+});
 ```
 
 ### Security Assessment Planning
@@ -167,13 +322,16 @@ nuclei -u https://app.example.com -t vulnerabilities/ -json -o nuclei-results.js
    - CIS Controls validation
 
 ### Post-Execution Coordination
-```bash
-# Store security results and alert other agents
-npx claude-flow@alpha memory store --key "aqe/security/vulnerabilities" --value "$(cat vulnerability-summary.json)"
-npx claude-flow@alpha memory store --key "aqe/security/compliance" --value "$(cat compliance-report.json)"
-npx claude-flow@alpha hooks notify --message "Security scanning completed: $(cat scan-summary.txt)"
-npx claude-flow@alpha hooks post-task --task-id "security-scanning"
-```
+
+**Native TypeScript Hooks (replaces bash commands):**
+
+All post-execution coordination is handled automatically via the `onPostTask()` lifecycle hook shown above. The agent coordinates through:
+
+- **Memory Store**: Results stored via `this.memoryStore.store()` with proper partitioning
+- **Event Bus**: Real-time updates via `this.eventBus.emit()` for fleet coordination
+- **Hook Manager**: Advanced validation via `VerificationHookManager`
+
+No external bash commands needed - all coordination is built into the agent's lifecycle hooks with 100-500x faster performance.
 
 ## Tool Integration
 
@@ -288,38 +446,63 @@ class TestWebSecurity:
 ## Memory Management
 
 ### Security Baseline Storage
-```bash
-# Store security baseline metrics
-npx claude-flow@alpha memory store --key "aqe/security/baselines" --value '{
-  "vulnerability_count": {
-    "critical": 0,
-    "high": 2,
-    "medium": 5,
-    "low": 10
+
+**Native TypeScript memory management:**
+
+```typescript
+// Store security baseline metrics
+await this.memoryStore.store('aqe/security/baselines', {
+  vulnerability_count: {
+    critical: 0,
+    high: 2,
+    medium: 5,
+    low: 10
   },
-  "security_score": 85,
-  "compliance_percentage": 95,
-  "last_scan_date": "2024-01-15T10:30:00Z"
-}'
+  security_score: 85,
+  compliance_percentage: 95,
+  last_scan_date: new Date().toISOString()
+}, {
+  partition: 'baselines',
+  ttl: 2592000 // 30 days
+});
+
+// Emit baseline update event
+this.eventBus.emit('security:baseline-updated', {
+  agentId: this.agentId,
+  securityScore: 85,
+  compliancePercentage: 95
+});
 ```
 
 ### Policy Configuration
-```bash
-# Configure security policies
-npx claude-flow@alpha memory store --key "aqe/security/policies" --value '{
-  "vulnerability_thresholds": {
-    "critical": 0,
-    "high": 5,
-    "medium": 20
+
+**Native TypeScript policy management:**
+
+```typescript
+// Configure security policies
+await this.memoryStore.store('aqe/security/policies', {
+  vulnerability_thresholds: {
+    critical: 0,
+    high: 5,
+    medium: 20
   },
-  "compliance_requirements": [
-    "OWASP_Top_10",
-    "PCI_DSS",
-    "SOC_2"
+  compliance_requirements: [
+    'OWASP_Top_10',
+    'PCI_DSS',
+    'SOC_2'
   ],
-  "scan_frequency": "daily",
-  "auto_remediation": true
-}'
+  scan_frequency: 'daily',
+  auto_remediation: true
+}, {
+  partition: 'configuration',
+  ttl: 0 // Never expire
+});
+
+// Emit policy update event
+this.eventBus.emit('security:policy-updated', {
+  agentId: this.agentId,
+  policiesUpdated: true
+});
 ```
 
 ## Agent Coordination

package/.claude/agents/qe-test-data-architect.md

@@ -12,17 +12,8 @@ capabilities:
   - realistic-data-synthesis
   - constraint-validation
   - data-versioning
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Architecting test data'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/schemas/*'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/test-data/templates'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/test-data/generated' --value '${DATA}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/test-data/patterns' --value '${PATTERNS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/test-data/schema-updated'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "1.0.0"
   stakeholders: ["Engineering", "QA", "Data Engineering"]
@@ -838,6 +829,53 @@ class TestDataVersionManager {
 }
 ```
 
+## Coordination Protocol
+
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies).
+
+**Automatic Lifecycle Hooks:**
+- `onPreTask()` - Called before task execution
+- `onPostTask()` - Called after task completion
+- `onTaskError()` - Called on task failure
+
+**Memory Integration:**
+```typescript
+// Store generated test data
+await this.memoryStore.store('aqe/test-data/generated', generatedData, {
+  partition: 'test_data',
+  ttl: 86400 // 24 hours
+});
+
+// Retrieve schemas
+const schemas = await this.memoryStore.retrieve('aqe/schemas/*', {
+  partition: 'schemas',
+  pattern: true
+});
+
+// Store data patterns
+await this.memoryStore.store('aqe/test-data/patterns', patterns, {
+  partition: 'patterns'
+});
+```
+
+**Event Bus Integration:**
+```typescript
+// Emit events for coordination
+this.eventBus.emit('test-data-architect:completed', {
+  agentId: this.agentId,
+  recordsGenerated: recordCount,
+  schemasCovered: schemaCount
+});
+
+// Listen for fleet events
+this.registerEventHandler({
+  eventType: 'test-data:generation-requested',
+  handler: async (event) => {
+    await this.generateTestData(event.schema, event.count);
+  }
+});
+```
+
 ## Integration Points
 
 ### Upstream Dependencies

package/.claude/agents/qe-test-executor.md

@@ -11,15 +11,8 @@ capabilities:
   - real-time-reporting
   - resource-optimization
   - performance-tracking
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Starting test execution'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/test-suites'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/test-execution/results' --value '${TEST_RESULTS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/tests/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "2.0.0"
   parallel_execution: true
@@ -46,15 +39,62 @@ The Test Executor Agent orchestrates parallel test execution across multiple fra
 ## Execution Workflow
 
 ### 1. Pre-Execution Phase
-```bash
-# Environment validation
-validate_test_environment()
-prepare_test_data()
-allocate_worker_pool()
-
-# Hooks integration
-npx claude-flow@alpha hooks pre-task --description "Starting test execution"
-npx claude-flow@alpha memory store --key "test/session/start" --value "{timestamp, config}"
+
+**Native TypeScript Hooks:**
+```typescript
+// Automatic lifecycle hook
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  await this.validateTestEnvironment();
+  await this.prepareTestData();
+  await this.allocateWorkerPool();
+
+  // Store session data
+  await this.memoryStore.store('test/session/start', {
+    timestamp: Date.now(),
+    config: this.config,
+    workersAllocated: this.workerPool.size
+  }, {
+    partition: 'test_sessions',
+    ttl: 86400
+  });
+
+  // Emit pre-execution event
+  this.eventBus.emit('test-executor:starting', {
+    agentId: this.agentId,
+    testSuites: this.testSuites.length
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store test results
+  await this.memoryStore.store('test/session/results', data.result, {
+    partition: 'test_results',
+    ttl: 86400
+  });
+
+  // Update metrics
+  await this.memoryStore.store('test/metrics/performance', {
+    duration: data.result.duration,
+    coverage: data.result.coverage,
+    testsExecuted: data.result.totalTests
+  }, {
+    partition: 'metrics'
+  });
+
+  this.eventBus.emit('test-executor:completed', {
+    agentId: this.agentId,
+    testResults: data.result
+  });
+}
+```
+
+**Advanced Verification:**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'test-execution',
+  context: { requiredVars: ['TEST_FRAMEWORK'], minMemoryMB: 2048 }
+});
 ```
 
 ### 2. Parallel Execution Coordination
@@ -280,43 +320,7 @@ async recoverTestEnvironment() {
 
 ## Integration Hooks
 
-### Pre-Execution Hooks
-```bash
-# Validate test environment
-npx claude-flow@alpha hooks validate-environment --framework "${FRAMEWORK}"
-
-# Prepare test data
-npx claude-flow@alpha hooks prepare-test-data --suite "${TEST_SUITE}"
-
-# Allocate resources
-npx claude-flow@alpha hooks allocate-resources --workers "${WORKER_COUNT}"
-```
-
-### Post-Execution Hooks
-```bash
-# Report test results
-npx claude-flow@alpha hooks report-results --format json --output results.json
-
-# Update test metrics
-npx claude-flow@alpha hooks update-metrics --duration "${DURATION}" --coverage "${COVERAGE}"
-
-# Cleanup resources
-npx claude-flow@alpha hooks cleanup-resources --preserve-artifacts true
-```
-
-## Memory Coordination
-
-### Test State Management
-```bash
-# Store test session data
-npx claude-flow@alpha memory store --key "test/session/${SESSION_ID}" --value "{config, workers, progress}"
-
-# Retrieve previous test results
-npx claude-flow@alpha memory retrieve --key "test/results/latest"
-
-# Update execution metrics
-npx claude-flow@alpha memory store --key "test/metrics/performance" --value "${PERFORMANCE_DATA}"
-```
+All integration hooks are now handled via **native TypeScript lifecycle hooks** (shown above in Pre-Execution Phase). No external bash commands needed - everything is automatic and 100-500x faster.
 
 ## Commands