agentic-qe 3.3.1 → 3.3.3

package/.claude/helpers/statusline-v3.cjs

@@ -31,11 +31,18 @@ const CONFIG = {
   flashAttentionTarget: '2.49x-7.47x',
   intelligenceTargetExp: 1000, // 1000 experiences = 100%
 
-  // Paths
-  memoryDb: '.agentic-qe/memory.db',
+  // Paths (V3 database takes priority - actively used)
+  memoryDbPaths: [
+    'v3/.agentic-qe/memory.db',    // V3 primary location (new schema)
+    '.agentic-qe/memory.db',        // Root fallback (old schema)
+  ],
   cveCache: '.agentic-qe/.cve-cache',
   cveCacheAge: 3600, // 1 hour
-  learningConfig: '.agentic-qe/learning-config.json',
+  learningConfigPaths: [
+    'v3/.agentic-qe/learning-config.json',      // V3 config
+    '.agentic-qe/data/learning-config.json',    // Root data dir
+    '.agentic-qe/learning-config.json',         // Root fallback
+  ],
   coverageFile: 'coverage/coverage-summary.json',
 
   // Domain list
@@ -207,25 +214,77 @@ function getTestCounts(projectDir) {
 }
 
 function getLearningMetrics(projectDir) {
-  const dbPath = path.join(projectDir, CONFIG.memoryDb);
+  // Find active database (V3 takes priority)
+  let dbPath = null;
+  let isV3Schema = false;
+
+  for (const relPath of CONFIG.memoryDbPaths) {
+    const candidate = path.join(projectDir, relPath);
+    if (fileExists(candidate)) {
+      // Check which schema this database uses
+      const hasV3Tables = sqlite3Query(candidate,
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='qe_patterns'", '') !== '';
+      const hasOldTables = sqlite3Query(candidate,
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='patterns'", '') !== '';
+
+      if (hasV3Tables || hasOldTables) {
+        dbPath = candidate;
+        isV3Schema = hasV3Tables;
+        break;
+      }
+    }
+  }
+
+  if (!dbPath) {
+    return {
+      patterns: 0, synthesized: 0, totalPatterns: 0, experiences: 0,
+      transfers: 0, successRate: 0, intelligencePct: 0, mode: 'off',
+      dbSource: 'none'
+    };
+  }
+
+  let patterns = 0, synthesized = 0, experiences = 0, transfers = 0, successRate = 0;
+
+  if (isV3Schema) {
+    // V3 Schema: qe_patterns, qe_trajectories, sona_patterns
+    patterns = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM qe_patterns')) || 0;
+    synthesized = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM sona_patterns')) || 0;
+
+    // Experiences: trajectories + claude-flow imported sessions
+    const trajectories = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM qe_trajectories')) || 0;
+    const cfExperiences = parseInt(sqlite3Query(dbPath,
+      "SELECT COUNT(*) FROM kv_store WHERE key LIKE 'cf:%'")) || 0;
+    experiences = trajectories + cfExperiences;
+
+    // V3 uses rl_q_values for transfer learning
+    transfers = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM rl_q_values')) || 0;
 
-  // Direct sqlite3 queries for accuracy
-  const patterns = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM patterns')) || 0;
-  const synthesized = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM synthesized_patterns')) || 0;
-  const experiences = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM learning_experiences')) || 0;
-  const transfers = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM transfer_registry')) || 0;
-  const successRate = parseFloat(sqlite3Query(dbPath,
-    'SELECT ROUND(AVG(success_rate)*100) FROM patterns WHERE success_rate > 0', '0')) || 0;
+    // Success rate from sona_patterns (claude-flow imports have outcome_success)
+    successRate = parseFloat(sqlite3Query(dbPath,
+      'SELECT ROUND(AVG(outcome_success)*100) FROM sona_patterns WHERE outcome_success > 0', '0')) || 0;
+  } else {
+    // Old Schema: patterns, learning_experiences, synthesized_patterns
+    patterns = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM patterns')) || 0;
+    synthesized = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM synthesized_patterns')) || 0;
+    experiences = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM learning_experiences')) || 0;
+    transfers = parseInt(sqlite3Query(dbPath, 'SELECT COUNT(*) FROM transfer_registry')) || 0;
+    successRate = parseFloat(sqlite3Query(dbPath,
+      'SELECT ROUND(AVG(success_rate)*100) FROM patterns WHERE success_rate > 0', '0')) || 0;
+  }
 
   // Intelligence % based on experiences (target: 1000 = 100%)
-  const intelligencePct = Math.min(100, Math.floor((experiences / CONFIG.intelligenceTargetExp) * 100));
+  const totalLearningData = patterns + synthesized + experiences;
+  const intelligencePct = Math.min(100, Math.floor((totalLearningData / CONFIG.intelligenceTargetExp) * 100));
 
-  // Get learning mode from config
+  // Get learning mode from config (check multiple paths)
   let mode = 'off';
-  const configPath = path.join(projectDir, CONFIG.learningConfig);
-  const config = readJsonFile(configPath);
-  if (config.enabled && config.scheduler?.mode) {
-    mode = config.scheduler.mode;
+  for (const relPath of CONFIG.learningConfigPaths) {
+    const configPath = path.join(projectDir, relPath);
+    const config = readJsonFile(configPath);
+    if (config.enabled && config.scheduler?.mode) {
+      mode = config.scheduler.mode;
+      break;
+    }
   }
 
   return {
@@ -237,6 +296,7 @@ function getLearningMetrics(projectDir) {
     successRate,
     intelligencePct,
     mode,
+    dbSource: isV3Schema ? 'v3' : 'root',
   };
 }
 
@@ -375,16 +435,19 @@ function getArchitectureMetrics(projectDir) {
     }
   }
 
-  // AgentDB size
+  // AgentDB size - check both V3 and root databases
   let agentDbSize = '';
-  const dbPath = path.join(projectDir, CONFIG.memoryDb);
-  if (fileExists(dbPath)) {
-    try {
-      const stats = fs.statSync(dbPath);
-      const sizeKB = Math.floor(stats.size / 1024);
-      agentDbSize = sizeKB > 1024 ? `${Math.floor(sizeKB / 1024)}M` : `${sizeKB}K`;
-    } catch {
-      // Ignore
+  for (const relPath of CONFIG.memoryDbPaths) {
+    const dbPath = path.join(projectDir, relPath);
+    if (fileExists(dbPath)) {
+      try {
+        const stats = fs.statSync(dbPath);
+        const sizeKB = Math.floor(stats.size / 1024);
+        agentDbSize = sizeKB > 1024 ? `${Math.floor(sizeKB / 1024)}M` : `${sizeKB}K`;
+        break; // Use first found database
+      } catch {
+        // Ignore
+      }
     }
   }
 
@@ -474,11 +537,14 @@ function generateStatusline(data) {
                         data.learning.mode === 'scheduled' ? `${c.yellow}◐` : `${c.dim}○`;
   const transferIndicator = data.learning.transfers > 10 ? `${c.brightGreen}●` :
                             data.learning.transfers > 0 ? `${c.yellow}◐` : `${c.dim}○`;
+  const dbSourceIndicator = data.learning.dbSource === 'v3' ? `${c.brightCyan}v3` :
+                            data.learning.dbSource === 'root' ? `${c.yellow}root` : `${c.dim}none`;
 
   let line3 = `${c.brightPurple}🎓 Learning${c.reset}     ${c.cyan}Patterns${c.reset} ${c.white}${padLeft(data.learning.totalPatterns, 4)}${c.reset}`;
   line3 += `  ${c.dim}│${c.reset}  ${c.cyan}Exp${c.reset} ${c.white}${padLeft(data.learning.experiences, 4)}${c.reset}`;
   line3 += `  ${c.dim}│${c.reset}  ${c.cyan}Mode${c.reset} ${modeIndicator}${data.learning.mode}${c.reset}`;
   line3 += `  ${c.dim}│${c.reset}  ${c.cyan}Transfer${c.reset} ${transferIndicator}${data.learning.transfers}${c.reset}`;
+  line3 += `  ${c.dim}│${c.reset}  ${c.cyan}DB${c.reset} ${dbSourceIndicator}${c.reset}`;
   lines.push(line3);
 
   // Line 4: Architecture Status
@@ -508,7 +574,10 @@ function generateJSON(data) {
     user: data.user,
     domains: data.domains,
     agents: data.agents,
-    learning: data.learning,
+    learning: {
+      ...data.learning,
+      dbSource: data.learning.dbSource,
+    },
     security: data.cve,
     context: data.context,
     architecture: data.arch,

package/README.md

@@ -11,7 +11,7 @@
 
 **V3 (Main)** | [V2 Documentation](v2/docs/V2-README.md) | [Changelog](CHANGELOG.md) | [Contributors](CONTRIBUTORS.md) | [Issues](https://github.com/proffesor-for-testing/agentic-qe/issues) | [Discussions](https://github.com/proffesor-for-testing/agentic-qe/discussions)
 
-> **V3** brings Domain-Driven Design architecture, 12 bounded contexts, 51 specialized QE agents, TinyDancer intelligent model routing, ReasoningBank learning with Dream cycles, HNSW vector search, mathematical Coherence verification (v3.3.0), and deep integration with [Claude Flow](https://github.com/ruvnet/claude-flow) and [Agentic Flow](https://github.com/ruvnet/agentic-flow).
+> **V3** brings Domain-Driven Design architecture, 12 bounded contexts, 51 specialized QE agents, TinyDancer intelligent model routing, ReasoningBank learning with Dream cycles, HNSW vector search, mathematical Coherence verification, full MinCut/Consensus integration across all 12 domains, and deep integration with [Claude Flow](https://github.com/ruvnet/claude-flow) and [Agentic Flow](https://github.com/ruvnet/agentic-flow).
 
 🏗️ **DDD Architecture** | 🧠 **ReasoningBank + Dream Cycles** | 🎯 **TinyDancer Model Routing** | 🔍 **HNSW Vector Search** | 👑 **Queen Coordinator** | 📊 **O(log n) Coverage** | 🔗 **Claude Flow Integration** | 🎯 **12 Bounded Contexts** | 📚 **61 QE Skills** | 🧬 **Coherence Verification** 
 
@@ -240,9 +240,9 @@ aqe hooks model-stats
 
 ---
 
-### 🔐 Consensus & MinCut Coordination
+### 🔐 Consensus & MinCut Coordination (v3.3.3)
 
-V3 includes advanced coordination mechanisms for reliable multi-agent decisions:
+V3.3.3 achieves **full MinCut/Consensus integration across all 12 domains**:
 
 | Feature | Description |
 |---------|-------------|
@@ -250,6 +250,9 @@ V3 includes advanced coordination mechanisms for reliable multi-agent decisions:
 | **MinCut Topology** | Graph-based self-healing agent coordination |
 | **Multi-Model Voting** | Aggregate decisions from multiple model tiers |
 | **Claim Verification** | Cryptographic verification of agent work claims |
+| **12/12 Domain Integration** | All domains use `verifyFinding()` for consensus |
+| **Topology-Aware Routing** | Routes tasks avoiding weak network vertices |
+| **Self-Healing Triggers** | `shouldPauseOperations()` for automatic recovery |
 
 ```bash
 # View consensus status

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 12 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 51 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "main": "./v3/dist/index.js",
   "types": "./v3/dist/index.d.ts",

package/scripts/sync-claude-flow.cjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Sync Claude Flow memories to AQE V3 database
+ */
+const fs = require('fs');
+const path = require('path');
+
+const projectRoot = process.cwd();
+const claudeFlowPath = path.join(projectRoot, '.claude-flow', 'memory', 'store.json');
+const aqeDbPath = path.join(projectRoot, 'v3', '.agentic-qe', 'memory.db');
+
+console.log('Claude Flow:', claudeFlowPath);
+console.log('AQE DB:', aqeDbPath);
+
+if (!fs.existsSync(claudeFlowPath)) {
+  console.error('Claude Flow store not found');
+  process.exit(1);
+}
+
+if (!fs.existsSync(aqeDbPath)) {
+  console.error('AQE DB not found');
+  process.exit(1);
+}
+
+const store = JSON.parse(fs.readFileSync(claudeFlowPath, 'utf-8'));
+const entries = store.entries || store;
+const keys = Object.keys(entries).filter(k => !k.startsWith('_') && k !== 'version');
+console.log('Entries to sync:', keys.length);
+
+const Database = require('better-sqlite3');
+const db = new Database(aqeDbPath);
+db.pragma('journal_mode = WAL');
+
+const insert = db.prepare(`
+  INSERT OR REPLACE INTO kv_store (key, namespace, value, created_at)
+  VALUES (?, ?, ?, ?)
+`);
+
+let count = 0;
+let learning = 0;
+
+// Also insert into sona_patterns for learning-related entries
+const insertSona = db.prepare(`
+  INSERT OR REPLACE INTO sona_patterns
+  (id, type, domain, action_type, outcome_reward, outcome_success, metadata, created_at)
+  VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+`);
+
+for (const key of keys) {
+  const value = entries[key];
+
+  // Always store in kv_store
+  insert.run(
+    'cf:' + key,
+    'claude-flow',
+    JSON.stringify(value),
+    Date.now()
+  );
+  count++;
+
+  // Store learning-relevant entries in sona_patterns too
+  const keyLower = key.toLowerCase();
+  if (keyLower.includes('pattern') || keyLower.includes('analysis') ||
+      keyLower.includes('learning') || keyLower.includes('agent') ||
+      keyLower.includes('outcome') || keyLower.includes('quality')) {
+
+    // Determine domain
+    let domain = 'general';
+    const domains = ['test-generation', 'coverage-analysis', 'security-compliance',
+                     'quality-assessment', 'code-intelligence'];
+    for (const d of domains) {
+      if (keyLower.includes(d.replace('-', ''))) {
+        domain = d;
+        break;
+      }
+    }
+
+    const id = 'cf-' + key.replace(/[^a-zA-Z0-9-]/g, '-').slice(0, 60);
+
+    try {
+      insertSona.run(
+        id,
+        'claude-flow-import',
+        domain,
+        'learn-from-session',
+        0.7, // Assume successful since it was stored
+        1,
+        JSON.stringify({ sourceKey: key, importedAt: new Date().toISOString() })
+      );
+      learning++;
+    } catch (e) {
+      // Ignore duplicate errors
+    }
+  }
+}
+
+db.close();
+console.log('Synced to kv_store:', count, 'entries');
+console.log('Synced to sona_patterns:', learning, 'learning entries');

package/v3/CHANGELOG.md

@@ -5,6 +5,139 @@ All notable changes to Agentic QE will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.3] - 2026-01-27
+
+### 🎯 Highlights
+
+**Full MinCut/Consensus Integration** - All 12 QE domains now have active MinCut topology awareness, multi-model consensus verification, and self-healing triggers. This completes the ADR-047 implementation with production-ready distributed coordination.
+
+**LLM Integration Across All Domains** - ADR-051 enables intelligent LLM-powered analysis in all 12 QE domains with TinyDancer model routing for cost optimization.
+
+### Added
+
+#### LLM Integration for All 12 QE Domains (ADR-051)
+- **test-generation** - AI-powered test synthesis with pattern learning
+- **test-execution** - Intelligent flaky test analysis and retry recommendations
+- **coverage-analysis** - LLM-assisted gap prioritization and risk scoring
+- **quality-assessment** - AI-driven quality gate decisions with explanations
+- **defect-intelligence** - ML-powered defect prediction and root cause analysis
+- **requirements-validation** - LLM testability analysis and BDD generation
+- **code-intelligence** - Semantic code search with natural language queries
+- **security-compliance** - AI vulnerability analysis with remediation guidance
+- **contract-testing** - LLM contract validation and breaking change detection
+- **visual-accessibility** - AI visual regression analysis and WCAG recommendations
+- **chaos-resilience** - Intelligent resilience assessment and failure prediction
+- **learning-optimization** - Pattern consolidation with LLM synthesis
+
+#### QE Agent Registry Fixes
+- Added missing agents to registry: `qe-product-factors-assessor`, `qe-quality-criteria-recommender`, `qe-test-idea-rewriter`
+- Fixed skill counts: 61 QE skills properly registered
+- Updated agent-to-domain mappings
+
+#### Documentation
+- **TinyDancer Integration Plan** - Detailed plan for model routing across domains
+- **Contract Validator LLM Docs** - LLM integration documentation for contract testing
+
+#### MinCut/Consensus Full Domain Integration (ADR-047, MM-001)
+- **All 12 domains** now actively use consensus verification (not just initialized)
+- **Topology-aware routing** - `getTopologyBasedRouting()` in all domains
+- **Self-healing triggers** - `shouldPauseOperations()` pauses work on critical topology
+
+| Domain | verifyFinding Calls | Self-Healing | Routing |
+|--------|---------------------|--------------|---------|
+| test-generation | 3 | ✅ | ✅ |
+| test-execution | 3 | ✅ | ✅ |
+| coverage-analysis | 3 | ✅ | ✅ |
+| quality-assessment | 2 | ✅ | ✅ |
+| defect-intelligence | 3 | ✅ | ✅ |
+| learning-optimization | 3 | ✅ | ✅ |
+| security-compliance | 2 | ✅ | ✅ |
+| chaos-resilience | 3 | ✅ | ✅ |
+| code-intelligence | 3 | ✅ | ✅ |
+| contract-testing | 3 | ✅ | ✅ |
+| requirements-validation | 3 | ✅ | ✅ |
+| visual-accessibility | 3 | ✅ | ✅ |
+
+#### Performance Benchmarks
+- **mincut-performance.test.ts** (20 tests) - Graph operations, health monitoring, memory usage
+- **consensus-latency.test.ts** (18 tests) - Finding verification, batch operations, strategy comparison
+
+#### Cross-Domain Integration Tests
+- **cross-domain-mincut-consensus.test.ts** (34 tests) - Queen→Domain bridge injection, topology coordination
+
+### Changed
+
+#### Domain Coordinators (all 12)
+- Added `verifyFinding()` calls for high-stakes decisions
+- Added `getTopologyBasedRouting()` method
+- Added `getDomainWeakVertices()` method
+- Added `isDomainWeakPoint()` method
+- Added self-healing with `shouldPauseOperations()` checks
+
+#### Type Exports
+- **consensus-enabled-domain.ts** - Re-export `ConsensusStats` type for domain use
+- **contract-testing/interfaces.ts** - Use proper `WeakVertex[]` and `DomainName[]` types
+- **code-intelligence/coordinator.ts** - Fixed routing type signatures
+
+### Fixed
+
+- **fix(types)**: ConsensusStats now properly exported from mixin module
+- **fix(types)**: DomainName[] type consistency across routing methods
+- **fix(coverage-analysis)**: Use `factors.contribution` instead of non-existent `factors.weight`
+- **fix(benchmarks)**: Relaxed timing thresholds for CI stability (0.2ms→0.5ms, 512B→1KB)
+
+### Documentation
+
+- **MINCUT_CONSENSUS_INTEGRATION_PLAN.md** - Updated status to IMPLEMENTED with completion metrics
+
+---
+
+## [3.3.2] - 2026-01-26
+
+### 🎯 Highlights
+
+**Automatic Dream Scheduling** - Dream Cycles are now actively triggered by QE agents instead of being passive-only. This upgrade brings QE v3 agent utilization to full capacity with cross-domain pattern consolidation.
+
+### Added
+
+#### DreamScheduler Service
+- **dream-scheduler.ts** - Central scheduling service for automatic dream cycles
+- Multiple trigger types:
+  | Trigger | When | Duration | Priority |
+  |---------|------|----------|----------|
+  | `scheduled` | Every 1 hour (configurable) | 30s | Low |
+  | `experience_threshold` | After 20 tasks accumulated | 10s | Medium |
+  | `quality_gate_failure` | On quality gate failure | 5s (quick) | High |
+  | `domain_milestone` | On domain milestone | 10s | Medium |
+  | `manual` | On-demand API call | Configurable | Varies |
+
+#### Cross-Domain Dream Integration
+- **EventBus integration** - `learning-optimization.dream.completed` event broadcasts insights
+- **TestGenerationCoordinator** - Subscribes to dream insights, auto-applies high-confidence patterns
+- **QualityAssessmentCoordinator** - Subscribes to dream insights for quality threshold tuning
+- **LearningOptimizationCoordinator** - Records task experiences, manages DreamScheduler lifecycle
+
+#### New Tests (84 total)
+- `dream-scheduler.test.ts` (unit) - 38 tests for scheduler triggers, lifecycle, status
+- `dream-scheduler.test.ts` (integration) - 46 tests for full pipeline, cross-domain events
+
+### Changed
+
+- **LearningOptimizationCoordinator** - Now initializes and manages DreamScheduler
+- **interfaces.ts** - Added `publishDreamCycleCompleted()` method
+- **domain-events.ts** - Added `DreamCycleCompletedPayload` type
+
+### Fixed
+
+- **fix(coordination)**: Wire Queen-Domain direct task execution integration
+- **fix(learning)**: Close ReasoningBank integration gaps for full learning pipeline
+
+### Documentation
+
+- `DREAM_SCHEDULER_DESIGN.md` - Architecture design document with trigger specifications
+
+---
+
 ## [3.3.1] - 2026-01-25
 
 ### 🎯 Highlights

package/v3/README.md

@@ -47,6 +47,7 @@ npx aqe test generate src/
 - **Queen-led Coordination** - 3-5x throughput with work stealing and consensus
 - **MinCut Topology** - Graph-based self-healing agent coordination
 - **Coherence Verification** (v3.3.0) - Mathematical proof of belief consistency using WASM engines
+- **MinCut/Consensus Integration** (v3.3.3) - Full 12/12 domain integration with self-healing
 - **Zero-Breaking-Changes Migration** - Full v2 backward compatibility
 - **Browser Automation** (v3.1.0) - @claude-flow/browser integration with 9 workflow templates
 
@@ -73,14 +74,17 @@ Background neural consolidation for continuous improvement:
 - **EWC++ Protection**: Elastic Weight Consolidation prevents catastrophic forgetting
 - **Novelty Scoring**: Prioritize learning from novel patterns
 
-### Consensus & MinCut Coordination
+### Consensus & MinCut Coordination (v3.3.3)
 
-Advanced coordination for reliable multi-agent decisions:
+Advanced coordination for reliable multi-agent decisions with **full 12/12 domain integration**:
 
 - **Byzantine Consensus**: Fault-tolerant voting for critical quality decisions
 - **MinCut Topology**: Graph-based self-healing agent coordination
 - **Multi-Model Voting**: Aggregate decisions from multiple model tiers
 - **Claim Verification**: Cryptographic verification of agent work claims
+- **12/12 Domain Coverage**: All domains actively use `verifyFinding()` for consensus
+- **Topology-Aware Routing**: `getTopologyBasedRouting()` avoids weak vertices
+- **Self-Healing Triggers**: `shouldPauseOperations()` enables automatic recovery
 
 ### Coherence-Gated Quality Engineering (v3.3.0)
 
@@ -486,7 +490,7 @@ console.log(`Quality gate: ${gate.value.passed ? 'PASSED' : 'FAILED'}`);
 | Memory | SQLite only | HNSW + SQLite hybrid |
 | Learning | Basic patterns | ReasoningBank + SONA + Dream Cycles |
 | Agents | 32 | 51 QE agents (44 main + 7 subagents) |
-| Skills | 35 | 60 QE skills (v2 + v3 domain skills) |
+| Skills | 35 | 61 QE skills (v2 + v3 domain skills) |
 | Coverage | O(n) | O(log n) |
 | Pattern Search | Linear | O(log n) HNSW indexing |
 | Coordination | Sequential | Queen + Work Stealing + Consensus |
@@ -600,11 +604,11 @@ Agentic QE includes 51 specialized quality engineering agents (44 main + 7 subag
 `qe-queen-coordinator`, `qe-fleet-commander`, `qe-integration-tester`, `qe-data-generator`, `qe-code-reviewer`
 
 ### Additional Agents (New in v3)
-`qe-product-factors-assessor` (SFDIPOT analysis), `qe-test-idea-rewriter` (passive→active test transforms)
+`qe-product-factors-assessor` (SFDIPOT analysis), `qe-quality-criteria-recommender` (HTSM v6.3 Quality Criteria), `qe-test-idea-rewriter` (passive→active test transforms)
 
 ## 61 QE Skills
 
-Agentic QE includes 60 domain-specific quality engineering skills that agents automatically apply:
+Agentic QE includes 61 domain-specific quality engineering skills that agents automatically apply:
 
 <details>
 <summary><b>View All 61 QE Skills</b></summary>