agentic-qe 1.0.1 → 1.0.3

package/.claude/agents/qe-api-contract-validator.md

@@ -12,17 +12,8 @@ capabilities:
   - consumer-impact-analysis
   - contract-testing
   - semantic-versioning-validation
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Validating API contracts'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/contracts/current'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/api-schemas/baseline'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/contracts/validation-result' --value '${RESULT}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/breaking-changes/detected' --value '${BREAKING_CHANGES}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/contracts/schema-updated'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "1.0.0"
   stakeholders: ["Engineering", "API Teams", "Integration Partners", "DevOps"]
@@ -935,6 +926,55 @@ class SemanticVersioningValidator {
 - **qe-fleet-commander**: Orchestrates contract validation
 - **qe-requirements-validator**: Validates API requirements
 
+## 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 baseline contracts and schemas
+  const contracts = await this.memoryStore.retrieve('aqe/contracts/current');
+  const baseline = await this.memoryStore.retrieve('aqe/api-schemas/baseline');
+  this.logger.info('Loaded API contracts and baseline schemas');
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store validation results and breaking changes
+  await this.memoryStore.store('aqe/contracts/validation-result', data.result.validation);
+  await this.memoryStore.store('aqe/breaking-changes/detected', data.result.breakingChanges);
+
+  // Emit events for downstream agents
+  this.eventBus.emit('contract-validator:completed', {
+    breakingChanges: data.result.breakingChanges.length,
+    validationStatus: data.result.validation.passed
+  });
+}
+
+protected async onPostEdit(data: { filePath: string; changes: any }): Promise<void> {
+  // Track schema updates
+  const fileName = data.filePath.split('/').pop();
+  await this.memoryStore.store(`aqe/contracts/schema-updated/${fileName}`, {
+    timestamp: Date.now(),
+    changes: data.changes
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'contract-validation',
+  context: {
+    requiredVars: ['NODE_ENV', 'API_VERSION'],
+    minMemoryMB: 512,
+    requiredKeys: ['aqe/api-schemas/baseline']
+  }
+});
+```
+
 ## Memory Keys
 
 ### Input Keys

package/.claude/agents/qe-chaos-engineer.md

@@ -13,17 +13,8 @@ capabilities:
   - hypothesis-testing
   - rollback-automation
   - observability-integration
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Chaos Engineer: Initializing chaos experiment'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/chaos/experiments/queue'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/chaos/safety/constraints'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/chaos/experiments/results' --value '${EXPERIMENT_RESULTS}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/chaos/metrics/resilience' --value '${RESILIENCE_METRICS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/chaos/config/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "2.0.0"
   frameworks: ["chaos-mesh", "gremlin", "litmus", "toxiproxy"]
@@ -176,21 +167,32 @@ const insights = generateResilience Insights({
 ## Integration Points
 
 ### Memory Coordination
-```bash
-# Store experiment configuration
-npx claude-flow@alpha memory store --key "aqe/chaos/experiments/${EXPERIMENT_ID}" --value "${EXPERIMENT_CONFIG}"
+```typescript
+// Store experiment configuration
+await this.memoryStore.store(`aqe/chaos/experiments/${experimentId}`, experimentConfig, {
+  partition: 'coordination',
+  ttl: 86400 // 24 hours
+});
 
-# Store safety constraints
-npx claude-flow@alpha memory store --key "aqe/chaos/safety/constraints" --value "${SAFETY_RULES}"
+// Store safety constraints
+await this.memoryStore.store('aqe/chaos/safety/constraints', safetyRules, {
+  partition: 'coordination'
+});
 
-# Store experiment results
-npx claude-flow@alpha memory store --key "aqe/chaos/results/${EXPERIMENT_ID}" --value "${RESULTS}"
+// Store experiment results
+await this.memoryStore.store(`aqe/chaos/results/${experimentId}`, results, {
+  partition: 'coordination'
+});
 
-# Store resilience metrics
-npx claude-flow@alpha memory store --key "aqe/chaos/metrics/resilience" --value "${RESILIENCE_METRICS}"
+// Store resilience metrics
+await this.memoryStore.store('aqe/chaos/metrics/resilience', resilienceMetrics, {
+  partition: 'coordination'
+});
 
-# Store rollback history
-npx claude-flow@alpha memory store --key "aqe/chaos/rollbacks/${EXPERIMENT_ID}" --value "${ROLLBACK_DATA}"
+// Store rollback history
+await this.memoryStore.store(`aqe/chaos/rollbacks/${experimentId}`, rollbackData, {
+  partition: 'coordination'
+});
 ```
 
 ### EventBus Integration
@@ -225,6 +227,52 @@ eventBus.publish('chaos:steady-state-violated', {
 - **QE Coverage Analyzer**: Measures chaos experiment coverage
 - **Fleet Commander**: Reports chaos experiment impact on fleet health
 
+## 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 experiment queue and safety constraints
+  const experiments = await this.memoryStore.retrieve('aqe/chaos/experiments/queue');
+  const safetyRules = await this.memoryStore.retrieve('aqe/chaos/safety/constraints');
+  const systemHealth = await this.memoryStore.retrieve('aqe/system/health');
+
+  this.logger.info('Chaos experiment initialized', {
+    pendingExperiments: experiments?.length || 0,
+    systemHealthy: systemHealth?.healthy || false
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store experiment results and resilience metrics
+  await this.memoryStore.store('aqe/chaos/experiments/results', data.result.experimentOutcomes);
+  await this.memoryStore.store('aqe/chaos/metrics/resilience', data.result.resilienceMetrics);
+
+  // Emit chaos completion event
+  this.eventBus.emit('chaos:experiment-completed', {
+    experimentId: data.assignment.id,
+    passed: data.result.steadyStateValidated,
+    rollbackTriggered: data.result.rollbackTriggered
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'chaos-experiment',
+  context: {
+    requiredVars: ['CHAOS_ENABLED', 'BLAST_RADIUS_MAX'],
+    minMemoryMB: 1024,
+    requiredKeys: ['aqe/chaos/safety/constraints', 'aqe/system/health']
+  }
+});
+```
+
 ## Memory Keys
 
 ### Input Keys
@@ -250,30 +298,34 @@ eventBus.publish('chaos:steady-state-violated', {
 ## Coordination Protocol
 
 ### Swarm Integration
-```bash
-# Initialize chaos engineering workflow
-npx claude-flow@alpha task orchestrate \
-  --task "Execute chaos experiment: database failure" \
-  --agents "qe-chaos-engineer,qe-performance-tester,qe-test-executor" \
-  --strategy "sequential-with-monitoring"
-
-# Coordinate with monitoring agents
-npx claude-flow@alpha agent spawn \
-  --type "monitoring-agent" \
-  --capabilities "metrics-collection,alerting"
+```typescript
+// Initialize chaos engineering workflow via task manager
+await this.taskManager.orchestrate({
+  task: 'Execute chaos experiment: database failure',
+  agents: ['qe-chaos-engineer', 'qe-performance-tester', 'qe-test-executor'],
+  strategy: 'sequential-with-monitoring'
+});
+
+// Coordinate with monitoring agents via EventBus
+this.eventBus.emit('chaos:spawn-monitor', {
+  agentType: 'monitoring-agent',
+  capabilities: ['metrics-collection', 'alerting']
+});
 ```
 
 ### Neural Pattern Training
-```bash
-# Train chaos patterns from experiment results
-npx claude-flow@alpha neural train \
-  --pattern-type "chaos-resilience" \
-  --training-data "experiment-outcomes"
-
-# Predict failure modes
-npx claude-flow@alpha neural predict \
-  --model-id "failure-prediction-model" \
-  --input "${SYSTEM_ARCHITECTURE}"
+```typescript
+// Train chaos patterns from experiment results via neural manager
+await this.neuralManager.trainPattern({
+  patternType: 'chaos-resilience',
+  trainingData: experimentOutcomes
+});
+
+// Predict failure modes
+const prediction = await this.neuralManager.predict({
+  modelId: 'failure-prediction-model',
+  input: systemArchitecture
+});
 ```
 
 ## Fault Injection Techniques

package/.claude/agents/qe-coverage-analyzer.md

@@ -11,15 +11,8 @@ capabilities:
   - multi-framework-support
   - sublinear-optimization
   - temporal-prediction
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Starting coverage analysis'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/coverage/gaps'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/coverage/results' --value '${COVERAGE_RESULTS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/coverage/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "2.0.0"
   optimization: "O(log n)"
@@ -52,39 +45,64 @@ Specialized agent for intelligent test coverage analysis and optimization using
 ## Analysis Workflow
 
 ### Phase 1: Pre-Execution Analysis
-```bash
-# Coverage matrix initialization
-npx claude-flow@alpha memory store --key "aqe/coverage/matrix-init" --value "$(coverage-matrix-sparse)"
-
-# Gap prediction using sublinear algorithms
-sublinear-predict --input coverage-history.json --output predicted-gaps.json
-
-# Critical path identification
-coverage-paths --algorithm johnson-lindenstrauss --target-dim log(n)
+```typescript
+// Coverage matrix initialization
+await this.memoryStore.store('aqe/coverage/matrix-init', coverageMatrixSparse, {
+  partition: 'coordination'
+});
+
+// Gap prediction using sublinear algorithms
+const predictedGaps = await this.sublinearPredictor.predict({
+  input: coverageHistory,
+  output: 'predicted-gaps'
+});
+
+// Critical path identification
+const criticalPaths = await this.coverageAnalyzer.identifyPaths({
+  algorithm: 'johnson-lindenstrauss',
+  targetDimension: Math.log(n)
+});
 ```
 
 ### Phase 2: Real-time Monitoring
-```bash
-# Live coverage tracking
-coverage-monitor --mode real-time --optimization sublinear
-
-# Gap detection during execution
-gap-detect --threshold 0.85 --algorithm spectral-sparse
-
-# Memory coordination
-npx claude-flow@alpha memory store --key "aqe/coverage/live-gaps" --value "$(current-gaps)"
+```typescript
+// Live coverage tracking
+await this.coverageMonitor.track({
+  mode: 'real-time',
+  optimization: 'sublinear'
+});
+
+// Gap detection during execution
+const gaps = await this.gapDetector.detect({
+  threshold: 0.85,
+  algorithm: 'spectral-sparse'
+});
+
+// Memory coordination
+await this.memoryStore.store('aqe/coverage/live-gaps', currentGaps, {
+  partition: 'coordination'
+});
 ```
 
 ### Phase 3: Post-Execution Optimization
-```bash
-# Coverage trend analysis
-trend-analyze --history 30d --predict-next-run
-
-# Optimization recommendations
-optimize-suggest --algorithm sublinear --target-coverage 95%
-
-# Report generation
-coverage-report --format enhanced --include-predictions
+```typescript
+// Coverage trend analysis
+const trends = await this.trendAnalyzer.analyze({
+  history: '30d',
+  predictNextRun: true
+});
+
+// Optimization recommendations
+const suggestions = await this.optimizer.suggest({
+  algorithm: 'sublinear',
+  targetCoverage: 0.95
+});
+
+// Report generation
+await this.reportGenerator.generate({
+  format: 'enhanced',
+  includePredictions: true
+});
 ```
 
 ## Sublinear Algorithm Features
@@ -110,30 +128,44 @@ coverage-report --format enhanced --include-predictions
 ## Memory Management
 
 ### Coverage Data Patterns
-```bash
-# Store coverage matrices (sparse format)
-npx claude-flow@alpha memory store --key "aqe/coverage/matrix-sparse" --value "$(sparse-matrix-json)"
-
-# Store gap detection results
-npx claude-flow@alpha memory store --key "aqe/coverage/gaps-detected" --value "$(gap-analysis-json)"
-
-# Store optimization recommendations
-npx claude-flow@alpha memory store --key "aqe/coverage/optimizations" --value "$(optimization-suggestions)"
-
-# Store trend analysis
-npx claude-flow@alpha memory store --key "aqe/coverage/trends" --value "$(trend-data-json)"
+```typescript
+// Store coverage matrices (sparse format)
+await this.memoryStore.store('aqe/coverage/matrix-sparse', sparseMatrixJson, {
+  partition: 'coordination'
+});
+
+// Store gap detection results
+await this.memoryStore.store('aqe/coverage/gaps-detected', gapAnalysisJson, {
+  partition: 'coordination'
+});
+
+// Store optimization recommendations
+await this.memoryStore.store('aqe/coverage/optimizations', optimizationSuggestions, {
+  partition: 'coordination'
+});
+
+// Store trend analysis
+await this.memoryStore.store('aqe/coverage/trends', trendDataJson, {
+  partition: 'coordination'
+});
 ```
 
 ### Cross-Agent Coordination
-```bash
-# Share findings with test execution agents
-npx claude-flow@alpha memory store --key "aqe/shared/critical-paths" --value "$(critical-paths-json)"
-
-# Coordinate with performance analyzer
-npx claude-flow@alpha memory store --key "aqe/shared/hotspots" --value "$(performance-hotspots)"
-
-# Update test prioritization
-npx claude-flow@alpha memory store --key "aqe/shared/test-priority" --value "$(priority-matrix)"
+```typescript
+// Share findings with test execution agents
+await this.memoryStore.store('aqe/shared/critical-paths', criticalPathsJson, {
+  partition: 'coordination'
+});
+
+// Coordinate with performance analyzer via EventBus
+this.eventBus.emit('coverage:hotspots-detected', {
+  hotspots: performanceHotspots
+});
+
+// Update test prioritization
+await this.memoryStore.store('aqe/shared/test-priority', priorityMatrix, {
+  partition: 'coordination'
+});
 ```
 
 ## Integration with Test Execution
@@ -261,6 +293,51 @@ agentic-qe agent optimize --name qe-coverage-analyzer --target 95% --time-budget
 agentic-qe agent analyze-multi --name qe-coverage-analyzer --frameworks "jest,pytest,junit"
 ```
 
+## 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 existing coverage gaps and baseline data
+  const gaps = await this.memoryStore.retrieve('aqe/coverage/gaps');
+  const trends = await this.memoryStore.retrieve('aqe/coverage/trends');
+
+  this.logger.info('Coverage analysis initialized', {
+    knownGaps: gaps?.length || 0,
+    algorithm: 'johnson-lindenstrauss'
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store coverage results and detected gaps
+  await this.memoryStore.store('aqe/coverage/results', data.result.coverageData);
+  await this.memoryStore.store('aqe/coverage/gaps', data.result.gaps);
+
+  // Emit coverage analysis completion
+  this.eventBus.emit('coverage-analyzer:completed', {
+    totalCoverage: data.result.coverageData.overallPercentage,
+    gapsDetected: data.result.gaps.length,
+    optimizationTime: data.result.executionTime
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'coverage-analysis',
+  context: {
+    requiredVars: ['NODE_ENV'],
+    minMemoryMB: 1024,
+    algorithm: 'sublinear'
+  }
+});
+```
+
 ## Fleet Integration
 
 ### EventBus Coordination

package/.claude/agents/qe-deployment-readiness.md

@@ -12,17 +12,8 @@ capabilities:
   - stakeholder-reporting
   - deployment-gate-enforcement
   - post-deployment-monitoring
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Assessing deployment readiness'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/quality-signals/*'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/deployment/history'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/deployment/decision' --value '${GO_NO_GO}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/deployment/risk-score' --value '${RISK_SCORE}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/deployment/config-updated'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "1.0.0"
   stakeholders: ["Engineering", "QA", "DevOps", "Product", "Executive"]
@@ -578,6 +569,52 @@ const postDeploymentMonitoring = {
 - **qe-fleet-commander**: Orchestrates readiness assessment workflow
 - **qe-production-intelligence**: Provides historical deployment insights
 
+## 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 all quality signals for deployment assessment
+  const qualitySignals = await this.memoryStore.retrievePattern('aqe/quality-signals/*');
+  const deploymentHistory = await this.memoryStore.retrieve('aqe/deployment/history');
+
+  this.logger.info('Deployment readiness assessment started', {
+    qualitySignalsCollected: Object.keys(qualitySignals).length,
+    historicalDeployments: deploymentHistory?.length || 0
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store deployment decision and risk score
+  await this.memoryStore.store('aqe/deployment/decision', data.result.decision);
+  await this.memoryStore.store('aqe/deployment/risk-score', data.result.riskScore);
+  await this.memoryStore.store('aqe/deployment/confidence', data.result.confidence);
+
+  // Emit deployment readiness event
+  this.eventBus.emit('deployment-readiness:assessed', {
+    decision: data.result.decision.status,
+    riskLevel: data.result.riskScore.level,
+    confidence: data.result.confidence.score
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'deployment-assessment',
+  context: {
+    requiredVars: ['DEPLOYMENT_ENV', 'VERSION'],
+    minMemoryMB: 512,
+    requiredKeys: ['aqe/quality-signals/code-quality', 'aqe/deployment/history']
+  }
+});
+```
+
 ## Memory Keys
 
 ### Input Keys

package/.claude/agents/qe-flaky-test-hunter.md

@@ -12,17 +12,8 @@ capabilities:
   - trend-tracking
   - reliability-scoring
   - predictive-flakiness
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Hunting flaky tests'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/test-results/history'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/flaky-tests/known'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/flaky-tests/detected' --value '${FLAKY_TESTS}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/test-reliability/scores' --value '${RELIABILITY}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/flaky-tests/test-updated'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "1.0.0"
   stakeholders: ["Engineering", "QA", "DevOps"]
@@ -962,6 +953,61 @@ class FlakinessPredictor {
 - **qe-fleet-commander**: Orchestrates flaky test hunting
 - **qe-quality-gate**: Blocks builds with too many flaky tests
 
+## 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 test history and known flaky tests
+  const testHistory = await this.memoryStore.retrieve('aqe/test-results/history');
+  const knownFlaky = await this.memoryStore.retrieve('aqe/flaky-tests/known');
+
+  this.logger.info('Flaky test detection started', {
+    historicalRuns: testHistory?.length || 0,
+    knownFlakyTests: knownFlaky?.length || 0
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store detected flaky tests and reliability scores
+  await this.memoryStore.store('aqe/flaky-tests/detected', data.result.flakyTests);
+  await this.memoryStore.store('aqe/test-reliability/scores', data.result.reliabilityScores);
+
+  // Emit flaky test detection event
+  this.eventBus.emit('flaky-hunter:completed', {
+    newFlakyTests: data.result.flakyTests.length,
+    quarantined: data.result.quarantined.length,
+    avgReliability: data.result.reliabilityScores.average
+  });
+}
+
+protected async onPostEdit(data: { filePath: string; changes: any }): Promise<void> {
+  // Track test file updates
+  if (data.filePath.includes('test')) {
+    await this.memoryStore.store(`aqe/flaky-tests/test-updated/${data.filePath}`, {
+      timestamp: Date.now(),
+      stabilizationAttempt: true
+    });
+  }
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'flaky-detection',
+  context: {
+    requiredVars: ['NODE_ENV', 'TEST_FRAMEWORK'],
+    minMemoryMB: 512,
+    minHistoricalRuns: 10
+  }
+});
+```
+
 ## Memory Keys
 
 ### Input Keys