agentic-qe 3.3.2 → 3.3.4

package/.claude/agents/v3/qe-tdd-specialist.md

@@ -211,6 +211,39 @@ Use via CLI: `aqe skills show tdd-london-chicago`
 Use via Claude Code: `Skill("tdd-london-chicago")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Operational Loop (CI/CD → Development)
+**Role**: CONSUMER - Receives flaky patterns to avoid in TDD cycles
+
+### On Startup, Query Operational Signals:
+```typescript
+const result = await mcp__agentic_qe__cross_phase_query({
+  loop: "operational",
+  maxAge: "30d"
+});
+
+// Apply test health learnings to TDD patterns
+for (const signal of result.signals) {
+  if (signal.recommendations?.antiPatterns) {
+    for (const antiPattern of signal.recommendations.antiPatterns) {
+      // Never use these patterns when writing tests
+      avoidPattern(antiPattern);
+    }
+  }
+}
+```
+
+### How to Use Injected Signals:
+1. **Anti-Patterns in RED phase**: Don't write tests using patterns in `antiPatterns`
+2. **Flaky Prevention**: Check `flakyPatterns[].pattern` before writing async tests
+3. **Stability Guidance**: Use `flakyPatterns[].fix` for similar test scenarios
+
+### Signal Flow:
+- **Consumes**: Flaky patterns and anti-patterns from qe-quality-gate
+- **Namespace**: `aqe/cross-phase/operational/test-health`
+- **Expected Signals**: Anti-patterns and flaky test fixes
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the test-generation bounded context (ADR-002).
 

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

@@ -219,6 +219,42 @@ Use via CLI: `aqe skills show shift-left-testing`
 Use via Claude Code: `Skill("shift-left-testing")`
 </skills_available>
 
+<cross_phase_memory>
+**QCSD Feedback Loop**: Operational Loop (CI/CD → Development)
+**Role**: CONSUMER - Receives flaky patterns and test health data
+
+### On Startup, Query Operational Signals:
+```typescript
+const result = await mcp__agentic_qe__cross_phase_query({
+  loop: "operational",
+  maxAge: "30d"
+});
+
+// Apply test health learnings to test architecture
+for (const signal of result.signals) {
+  if (signal.flakyPatterns) {
+    for (const flaky of signal.flakyPatterns) {
+      // Avoid patterns that cause flakiness
+      addAntiPattern(flaky.pattern, flaky.fix);
+    }
+  }
+  if (signal.recommendations?.antiPatterns) {
+    applyAntiPatterns(signal.recommendations.antiPatterns);
+  }
+}
+```
+
+### How to Use Injected Signals:
+1. **Anti-Patterns**: Avoid patterns listed in `signal.recommendations.antiPatterns`
+2. **Flaky Fixes**: Apply `flakyPattern.fix` recommendations to similar test structures
+3. **Architecture Guidance**: Use `signal.recommendations.forTestArchitect`
+
+### Signal Flow:
+- **Consumes**: Flaky patterns and gate failures from qe-quality-gate
+- **Namespace**: `aqe/cross-phase/operational/test-health`
+- **Expected Signals**: Flaky test patterns with root causes and fixes
+</cross_phase_memory>
+
 <coordination_notes>
 **V3 Architecture**: This agent operates within the test-generation bounded context (ADR-002).
 

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/.claude/skills/README.md

@@ -1,124 +1,50 @@
-# Claude Skills Collection
+# AQE Skills Index
 
-Personal skill library for Dragan Spiridonov - Agentic Quality Engineer & Founder of Quantum Quality Engineering.
-
-## Available Skills
-
-### Core Quality Skills
-- **[holistic-testing-pact](./holistic-testing-pact/)** - Evolved Holistic Testing Model with PACT principles (Proactive, Autonomous, Collaborative, Targeted)
-- **[context-driven-testing](./context-driven-testing/)** - Context-driven philosophy and Rapid Software Testing techniques
-- **[agentic-quality-engineering](./agentic-quality-engineering/)** - AI agents as quality work force multipliers
-- **[exploratory-testing-advanced](./exploratory-testing-advanced/)** - Deep dive into RST heuristics and session-based testing
-- **[risk-based-testing](./risk-based-testing/)** - Risk assessment frameworks and prioritization
-
-### Development Practices
-- **[tdd-london-chicago](./tdd-london-chicago/)** - Both schools of TDD with examples and guidance
-- **[xp-practices](./xp-practices/)** - Pair/ensemble programming patterns and XP methodologies
-- **[refactoring-patterns](./refactoring-patterns/)** - Safe refactoring techniques and code improvement patterns
+This directory contains Quality Engineering skills installed by `aqe init`.
 
-### Testing Patterns
-- **[api-testing-patterns](./api-testing-patterns/)** - REST, GraphQL, contract testing, and integration approaches
-- **[performance-testing](./performance-testing/)** - Load, stress, soak testing strategies and optimization
-- **[security-testing](./security-testing/)** - OWASP Top 10, vulnerability scanning, and secure coding
-- **[test-automation-strategy](./test-automation-strategy/)** - When/how to automate, avoiding anti-patterns
+> **Note**: Claude Flow platform skills (agentdb, n8n, github, flow-nexus, etc.) are managed
+> separately by the claude-flow package. This directory contains only QE-specific skills.
 
-### Communication & Process
-- **[technical-writing](./technical-writing/)** - Clear, engaging technical content for practitioners
-- **[bug-reporting-excellence](./bug-reporting-excellence/)** - Writing actionable, clear bug reports
-- **[code-review-quality](./code-review-quality/)** - Effective code reviews that teach and improve
+## Summary
 
-### Professional Skills
-- **[consultancy-practices](./consultancy-practices/)** - Assessment, transformation, and advisory work
-- **[quality-metrics](./quality-metrics/)** - Meaningful metrics vs. vanity metrics
+- **Total Skills**: 1
+- **V2 Methodology Skills**: 0
+- **V3 Domain Skills**: 1
 
-## How to Use
+## V2 Methodology Skills (0)
 
-Each skill contains a `SKILL.md` file with:
-- Core principles and philosophy
-- Practical techniques and examples
-- Common pitfalls and anti-patterns
-- Context-appropriate guidance
-- Real-world examples from production
+Version-agnostic quality engineering best practices from the QE community.
 
-## Philosophy
+*None installed*
 
-All skills reflect these values:
-- **Context over dogma** - Best practices are contextual, not universal
-- **Practice over theory** - Based on 12+ years in production, not just study
-- **Value over compliance** - Focus on customer value, not process adherence
-- **Pragmatism over purity** - Blend approaches as needed for your context
-- **Quality built-in** - Prevention over detection, shift-left thinking
+## V3 Domain Skills (1)
 
-## Skill Categories
+V3-specific implementation guides for the 12 DDD bounded contexts.
 
-### For Quality Engineers
-Start with: holistic-testing-pact, context-driven-testing, exploratory-testing-advanced, risk-based-testing
+### qe-a11y-ally (visual-accessibility domain)
 
-### For Developers
-Start with: tdd-london-chicago, refactoring-patterns, code-review-quality
+**File:** `library/qe-a11y-ally.md`
 
-### For Team Leads
-Start with: quality-metrics, consultancy-practices, xp-practices
+WCAG accessibility auditing with **mandatory video accessibility generation**. This skill ensures the full V3 video pipeline is executed.
 
-### For Everyone
-Start with: technical-writing, bug-reporting-excellence
+**Key Features:**
+- WCAG 2.1/2.2 AA/AAA compliance auditing
+- Video detection and download
+- Frame extraction with ffmpeg (10 frames @ 3s intervals)
+- AI frame analysis with Claude Vision
+- WebVTT caption generation (`*-captions.vtt`)
+- Audio description generation (`*-audiodesc.vtt`)
+- EU compliance (EN 301 549, EAA, BITV 2.0)
 
-## Integration with Tools
+**Output:** `docs/accessibility/captions/{page-slug}/`
 
-These skills work well with:
-- **Claude Code** - Copy to project `.claude/` directory
-- **IDE Plugins** - Reference during development
-- **CI/CD Pipelines** - Embed principles in automation
-- **Team Wikis** - Share as team knowledge base
+**Usage:**
+```
+/qe-a11y-ally https://example.com/page-with-video
+```
 
-## About
 
-Created by Dragan Spiridonov (profa):
-- Founder, Quantum Quality Engineering
-- Member, Global Agentics Foundation
-- Establishing Serbian Agentic Foundation Chapter
-- 25+ years IT experience
-- 8 years leading QA/QE at Alchemy
-- 12+ years implementing quality practices in production
-
-## Current Work
-
-Building the Serbian Agentic Foundation community in partnership with StartIt centers across Serbia, starting with Novi Sad in October 2025.
-
-## Skill Development
-
-### Recently Added
-- api-testing-patterns
-- quality-metrics
-- consultancy-practices
-- performance-testing
-- security-testing
-- bug-reporting-excellence
-- refactoring-patterns
-- code-review-quality
-
-### Future Considerations
-- chaos-engineering
-- observability-practices
-- incident-management
-- technical-leadership
-- team-building
-- public-speaking
-
-## Contributing
-
-These skills evolve based on:
-- Real production experience
-- Community feedback
-- New techniques and tools
-- Lessons learned from failures
-
-Feedback welcome through discussions and community channels.
-
-## License
-
-These skills document proven practices and methodologies. Use freely with attribution.
 
 ---
 
-*These skills are living documents that evolve with practice and community input. Last updated: October 2025*
+*Generated by AQE v3 init on 2026-01-25T14:23:40.890Z*