@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/learning/real-qe-reasoning-bank.ts

@@ -1,833 +0,0 @@
-/**
- * Real QE ReasoningBank - Standalone Implementation
- * ADR-021: QE ReasoningBank for Pattern Learning
- *
- * This implementation:
- * - Standalone implementation (HybridReasoningBank has problematic singleton behavior)
- * - Uses REAL transformer embeddings (@xenova/transformers)
- * - Uses REAL SQLite persistence (better-sqlite3)
- * - Uses REAL HNSW indexing (hnswlib-node)
- *
- * NO fake claims, NO hash-based "embeddings", NO silent fallbacks.
- *
- * NOTE: We don't extend HybridReasoningBank because:
- * 1. It has a bug where Database is not imported (requires globalThis polyfill)
- * 2. It uses SharedMemoryPool singleton that causes repeated re-initialization
- * 3. Standalone implementation gives us full control and better performance
- */
-import { v4 as uuidv4 } from 'uuid';
-import {
-  computeRealEmbedding,
-  computeBatchEmbeddings,
-  cosineSimilarity,
-  isTransformerAvailable,
-  getEmbeddingDimension,
-  clearEmbeddingCache,
-  type EmbeddingConfig,
-} from './real-embeddings.js';
-import {
-  SQLitePatternStore,
-  createSQLitePatternStore,
-  type SQLitePersistenceConfig,
-} from './sqlite-persistence.js';
-import {
-  QEPattern,
-  QEPatternType,
-  QEDomain,
-  QEPatternContext,
-  CreateQEPatternOptions,
-  detectQEDomain,
-  detectQEDomains,
-  mapQEDomainToAQE,
-  QE_DOMAIN_LIST,
-} from './qe-patterns.js';
-import {
-  QEGuidance,
-  getGuidance,
-  getCombinedGuidance,
-  generateGuidanceContext,
-  checkAntiPatterns,
-} from './qe-guidance.js';
-import type { Result } from '../shared/types/index.js';
-import { ok, err } from '../shared/types/index.js';
-
-// ============================================================================
-// Configuration
-// ============================================================================
-
-export interface RealQEReasoningBankConfig {
-  /** SQLite database configuration */
-  sqlite: Partial<SQLitePersistenceConfig>;
-
-  /** Embedding model configuration */
-  embeddings: Partial<EmbeddingConfig>;
-
-  /** Enable learning from outcomes */
-  enableLearning: boolean;
-
-  /** Enable task routing */
-  enableRouting: boolean;
-
-  /** Enable guidance generation */
-  enableGuidance: boolean;
-
-  /** HNSW index parameters */
-  hnsw: {
-    M: number;
-    efConstruction: number;
-    efSearch: number;
-  };
-
-  /** Routing weights */
-  routingWeights: {
-    similarity: number;
-    performance: number;
-    capabilities: number;
-  };
-}
-
-export const DEFAULT_REAL_CONFIG: RealQEReasoningBankConfig = {
-  sqlite: {
-    dbPath: '.agentic-qe/qe-patterns.db',
-    walMode: true,
-  },
-  embeddings: {
-    modelName: 'Xenova/all-MiniLM-L6-v2',
-    quantized: true,
-    enableCache: true,
-  },
-  enableLearning: true,
-  enableRouting: true,
-  enableGuidance: true,
-  hnsw: {
-    M: 16,
-    efConstruction: 200,
-    efSearch: 100,
-  },
-  routingWeights: {
-    similarity: 0.3,
-    performance: 0.4,
-    capabilities: 0.3,
-  },
-};
-
-// ============================================================================
-// Routing Types
-// ============================================================================
-
-export interface RealQERoutingRequest {
-  task: string;
-  taskType?: 'test-generation' | 'analysis' | 'debugging' | 'optimization';
-  domain?: QEDomain;
-  capabilities?: string[];
-  context?: Partial<QEPatternContext>;
-}
-
-export interface RealQERoutingResult {
-  recommendedAgent: string;
-  confidence: number;
-  alternatives: Array<{ agent: string; score: number }>;
-  domains: QEDomain[];
-  patterns: QEPattern[];
-  guidance: string[];
-  reasoning: string;
-  latencyMs: number;
-}
-
-export interface LearningOutcome {
-  patternId: string;
-  success: boolean;
-  metrics?: {
-    testsPassed?: number;
-    testsFailed?: number;
-    coverageImprovement?: number;
-    executionTimeMs?: number;
-  };
-  feedback?: string;
-}
-
-// ============================================================================
-// Statistics
-// ============================================================================
-
-export interface RealQEReasoningBankStats {
-  totalPatterns: number;
-  byDomain: Record<QEDomain, number>;
-  byTier: Record<string, number>;
-  routingRequests: number;
-  avgRoutingLatencyMs: number;
-  p95RoutingLatencyMs: number;
-  learningOutcomes: number;
-  patternSuccessRate: number;
-  embeddingCacheSize: number;
-  transformerAvailable: boolean;
-  embeddingDimension: number;
-  sqliteDbPath: string;
-}
-
-// ============================================================================
-// Real QE ReasoningBank Implementation
-// ============================================================================
-
-/**
- * Real QE ReasoningBank - Standalone Implementation
- *
- * Standalone implementation with REAL:
- * - Transformer embeddings (all-MiniLM-L6-v2, 384 dimensions)
- * - SQLite persistence (better-sqlite3 with WAL mode)
- * - HNSW vector indexing (hnswlib-node)
- *
- * Does NOT extend HybridReasoningBank due to upstream bugs and problematic singleton behavior.
- */
-export class RealQEReasoningBank {
-  private readonly qeConfig: RealQEReasoningBankConfig;
-  private sqliteStore: SQLitePatternStore;
-  private hnswIndex: HierarchicalNSW | null = null;
-  private patternIdMap: Map<number, string> = new Map();
-  private initialized = false;
-
-  // Statistics tracking
-  private stats = {
-    routingRequests: 0,
-    totalRoutingLatency: 0,
-    routingLatencies: [] as number[],
-    learningOutcomes: 0,
-    successfulOutcomes: 0,
-  };
-
-  // QE Agent capability mapping
-  private readonly agentCapabilities: Record<string, {
-    domains: QEDomain[];
-    capabilities: string[];
-    performanceScore: number;
-  }> = {
-    'qe-test-generator': {
-      domains: ['test-generation'],
-      capabilities: ['test-generation', 'tdd', 'bdd', 'unit-test', 'integration-test'],
-      performanceScore: 0.85,
-    },
-    'qe-coverage-analyzer': {
-      domains: ['coverage-analysis'],
-      capabilities: ['coverage-analysis', 'gap-detection', 'risk-scoring'],
-      performanceScore: 0.92,
-    },
-    'qe-coverage-specialist': {
-      domains: ['coverage-analysis'],
-      capabilities: ['sublinear-analysis', 'branch-coverage', 'mutation-testing'],
-      performanceScore: 0.88,
-    },
-    'qe-test-architect': {
-      domains: ['test-generation', 'coverage-analysis'],
-      capabilities: ['test-strategy', 'test-pyramid', 'architecture'],
-      performanceScore: 0.9,
-    },
-    'qe-api-contract-validator': {
-      domains: ['contract-testing'],
-      capabilities: ['contract-testing', 'openapi', 'graphql', 'pact'],
-      performanceScore: 0.87,
-    },
-    'qe-security-auditor': {
-      domains: ['security-compliance'],
-      capabilities: ['sast', 'dast', 'vulnerability', 'owasp'],
-      performanceScore: 0.82,
-    },
-    'qe-visual-tester': {
-      domains: ['visual-accessibility'],
-      capabilities: ['screenshot', 'visual-regression', 'percy', 'chromatic'],
-      performanceScore: 0.8,
-    },
-    'qe-a11y-ally': {
-      domains: ['visual-accessibility'],
-      capabilities: ['wcag', 'aria', 'screen-reader', 'contrast'],
-      performanceScore: 0.85,
-    },
-    'qe-performance-tester': {
-      domains: ['chaos-resilience'],
-      capabilities: ['load-testing', 'stress-testing', 'k6', 'artillery'],
-      performanceScore: 0.83,
-    },
-    'qe-flaky-investigator': {
-      domains: ['test-execution'],
-      capabilities: ['flaky-detection', 'test-stability', 'retry'],
-      performanceScore: 0.78,
-    },
-    'qe-chaos-engineer': {
-      domains: ['chaos-resilience'],
-      capabilities: ['chaos-testing', 'resilience', 'fault-injection'],
-      performanceScore: 0.75,
-    },
-  };
-
-  constructor(config: Partial<RealQEReasoningBankConfig> = {}) {
-    this.qeConfig = { ...DEFAULT_REAL_CONFIG, ...config };
-    this.sqliteStore = createSQLitePatternStore(this.qeConfig.sqlite);
-  }
-
-  /**
-   * Initialize the QE ReasoningBank
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
-
-    const startTime = performance.now();
-
-    // Initialize SQLite persistence
-    await this.sqliteStore.initialize();
-    console.log('[RealQEReasoningBank] SQLite persistence initialized');
-
-    // Initialize HNSW index
-    await this.initializeHNSW();
-    console.log('[RealQEReasoningBank] HNSW index initialized');
-
-    // Load existing patterns into HNSW
-    await this.loadPatternsIntoHNSW();
-
-    // Load foundational patterns if database is empty
-    const stats = this.sqliteStore.getStats();
-    if (stats.totalPatterns === 0) {
-      await this.loadFoundationalPatterns();
-    }
-
-    this.initialized = true;
-    const initTime = performance.now() - startTime;
-    console.log(`[RealQEReasoningBank] Fully initialized in ${initTime.toFixed(0)}ms`);
-  }
-
-  /**
-   * Initialize HNSW index for fast similarity search
-   */
-  private async initializeHNSW(): Promise<void> {
-    try {
-      const hnswModule = await import('hnswlib-node');
-      const HierarchicalNSW = hnswModule.HierarchicalNSW || hnswModule.default;
-      const dimension = getEmbeddingDimension();
-
-      this.hnswIndex = new HierarchicalNSW('cosine', dimension) as unknown as HierarchicalNSW;
-      this.hnswIndex!.initIndex(
-        100000, // max elements
-        this.qeConfig.hnsw.M,
-        this.qeConfig.hnsw.efConstruction
-      );
-      this.hnswIndex!.setEf(this.qeConfig.hnsw.efSearch);
-
-      console.log(`[RealQEReasoningBank] HNSW initialized: dim=${dimension}, M=${this.qeConfig.hnsw.M}`);
-    } catch (error) {
-      console.error('[RealQEReasoningBank] HNSW initialization failed:', error);
-      throw error; // Don't silently fall back - fail explicitly
-    }
-  }
-
-  /**
-   * Load existing patterns into HNSW index
-   */
-  private async loadPatternsIntoHNSW(): Promise<void> {
-    if (!this.hnswIndex) return;
-
-    const embeddings = this.sqliteStore.getAllEmbeddings();
-    let loaded = 0;
-
-    for (const { patternId, embedding } of embeddings) {
-      const index = this.hnswIndex.getCurrentCount();
-      this.hnswIndex.addPoint(embedding, index);
-      this.patternIdMap.set(index, patternId);
-      loaded++;
-    }
-
-    console.log(`[RealQEReasoningBank] Loaded ${loaded} patterns into HNSW index`);
-  }
-
-  /**
-   * Load foundational QE patterns
-   */
-  private async loadFoundationalPatterns(): Promise<void> {
-    const foundationalPatterns: CreateQEPatternOptions[] = [
-      {
-        patternType: 'test-template',
-        name: 'AAA Unit Test',
-        description: 'Arrange-Act-Assert pattern for clear, maintainable unit tests',
-        template: {
-          type: 'code',
-          content: `describe('{{className}}', () => {
-  describe('{{methodName}}', () => {
-    it('should {{expectedBehavior}}', {{async}} () => {
-      // Arrange
-      {{arrangeCode}}
-
-      // Act
-      {{actCode}}
-
-      // Assert
-      {{assertCode}}
-    });
-  });
-});`,
-          variables: [
-            { name: 'className', type: 'string', required: true },
-            { name: 'methodName', type: 'string', required: true },
-            { name: 'expectedBehavior', type: 'string', required: true },
-          ],
-        },
-        context: { testType: 'unit', tags: ['unit-test', 'aaa', 'best-practice'] },
-      },
-      {
-        patternType: 'coverage-strategy',
-        name: 'Risk-Based Coverage',
-        description: 'Prioritize coverage by code risk and complexity',
-        template: {
-          type: 'prompt',
-          content: 'Analyze coverage gaps focusing on critical business logic, error handling, and high-complexity functions.',
-          variables: [],
-        },
-        context: { tags: ['coverage', 'risk-based'] },
-      },
-    ];
-
-    for (const options of foundationalPatterns) {
-      try {
-        await this.storeQEPattern(options);
-      } catch (error) {
-        console.warn(`[RealQEReasoningBank] Failed to load foundational pattern: ${options.name}`, error);
-      }
-    }
-
-    console.log(`[RealQEReasoningBank] Loaded ${foundationalPatterns.length} foundational patterns`);
-  }
-
-  /**
-   * Store a QE pattern with REAL embeddings
-   */
-  async storeQEPattern(options: CreateQEPatternOptions): Promise<Result<QEPattern>> {
-    // Require explicit initialization - don't auto-initialize to avoid memory issues
-
-    try {
-      // Generate REAL embedding using transformer model
-      const textToEmbed = `${options.name} ${options.description || ''} ${options.context?.tags?.join(' ') || ''}`;
-      const embedding = await computeRealEmbedding(textToEmbed, this.qeConfig.embeddings);
-
-      // Detect QE domain
-      const qeDomain = detectQEDomain(textToEmbed) || 'test-generation';
-
-      // Generate pattern ID
-      const patternId = uuidv4();
-
-      // Create pattern object
-      const pattern: QEPattern = {
-        id: patternId,
-        patternType: options.patternType,
-        qeDomain,
-        domain: mapQEDomainToAQE(qeDomain),
-        name: options.name,
-        description: options.description || '',
-        confidence: 0.5,
-        usageCount: 0,
-        successRate: 0,
-        qualityScore: 0,
-        tier: 'short-term',
-        template: options.template as QEPattern['template'],
-        context: { tags: [], ...options.context } as QEPatternContext,
-        createdAt: new Date(),
-        lastUsedAt: new Date(),
-        successfulUses: 0,
-        embedding,
-      };
-
-      // Store in SQLite
-      this.sqliteStore.storePattern(pattern, embedding);
-
-      // Add to HNSW index
-      if (this.hnswIndex) {
-        const index = this.hnswIndex.getCurrentCount();
-        this.hnswIndex.addPoint(embedding, index);
-        this.patternIdMap.set(index, patternId);
-      }
-
-      return ok(pattern);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Search patterns using REAL vector similarity (HNSW)
-   */
-  async searchQEPatterns(
-    query: string,
-    options: { limit?: number; domain?: QEDomain; minSimilarity?: number } = {}
-  ): Promise<Result<Array<{ pattern: QEPattern; similarity: number }>>> {
-    // Require explicit initialization - don't auto-initialize to avoid memory issues
-
-    const startTime = performance.now();
-
-    try {
-      if (!this.hnswIndex) {
-        return err(new Error('HNSW index not available'));
-      }
-
-      // Generate REAL embedding for query
-      const queryEmbedding = await computeRealEmbedding(query, this.qeConfig.embeddings);
-
-      // Search HNSW index
-      const limit = options.limit || 10;
-      const results = this.hnswIndex.searchKnn(queryEmbedding, limit * 2); // Get extra for filtering
-
-      const patterns: Array<{ pattern: QEPattern; similarity: number }> = [];
-
-      for (let i = 0; i < results.neighbors.length && patterns.length < limit; i++) {
-        const hnswIndex = results.neighbors[i];
-        const distance = results.distances[i];
-        const similarity = 1 - distance; // Convert distance to similarity
-
-        if (options.minSimilarity && similarity < options.minSimilarity) {
-          continue;
-        }
-
-        const patternId = this.patternIdMap.get(hnswIndex);
-        if (!patternId) continue;
-
-        const pattern = this.sqliteStore.getPattern(patternId);
-        if (!pattern) continue;
-
-        // Filter by domain if specified
-        if (options.domain && pattern.qeDomain !== options.domain) {
-          continue;
-        }
-
-        patterns.push({ pattern, similarity });
-      }
-
-      const searchTime = performance.now() - startTime;
-      if (searchTime > 10) {
-        console.warn(`[RealQEReasoningBank] Slow search: ${searchTime.toFixed(1)}ms`);
-      }
-
-      return ok(patterns);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Route a task to optimal agent
-   */
-  async routeTask(request: RealQERoutingRequest): Promise<Result<RealQERoutingResult>> {
-    // Require explicit initialization - don't auto-initialize to avoid memory issues
-
-    const startTime = performance.now();
-    this.stats.routingRequests++;
-
-    try {
-      // Detect domains
-      const detectedDomains = request.domain
-        ? [request.domain]
-        : detectQEDomains(request.task);
-
-      if (detectedDomains.length === 0) {
-        detectedDomains.push('test-generation');
-      }
-
-      // Search for similar patterns
-      const searchResult = await this.searchQEPatterns(request.task, {
-        limit: 10,
-        domain: detectedDomains[0],
-      });
-
-      const patterns = searchResult.success ? searchResult.value.map(r => r.pattern) : [];
-
-      // Calculate agent scores
-      const agentScores: Array<{ agent: string; score: number; reasoning: string[] }> = [];
-
-      for (const [agentType, profile] of Object.entries(this.agentCapabilities)) {
-        let score = 0;
-        const reasoning: string[] = [];
-
-        // Domain match
-        const domainMatch = detectedDomains.filter(d => profile.domains.includes(d)).length;
-        const domainScore = domainMatch > 0 ? (domainMatch / detectedDomains.length) * 0.4 : 0;
-        score += domainScore * this.qeConfig.routingWeights.similarity;
-        if (domainScore > 0) reasoning.push(`Domain: ${(domainScore * 100).toFixed(0)}%`);
-
-        // Capability match
-        if (request.capabilities && request.capabilities.length > 0) {
-          const capMatch = request.capabilities.filter(c =>
-            profile.capabilities.some(pc => pc.toLowerCase().includes(c.toLowerCase()))
-          ).length;
-          const capScore = capMatch > 0 ? (capMatch / request.capabilities.length) * 0.3 : 0;
-          score += capScore * this.qeConfig.routingWeights.capabilities;
-          if (capScore > 0) reasoning.push(`Caps: ${(capScore * 100).toFixed(0)}%`);
-        } else {
-          score += 0.15 * this.qeConfig.routingWeights.capabilities;
-        }
-
-        // Performance
-        score += profile.performanceScore * 0.3 * this.qeConfig.routingWeights.performance;
-        reasoning.push(`Perf: ${(profile.performanceScore * 100).toFixed(0)}%`);
-
-        agentScores.push({ agent: agentType, score, reasoning });
-      }
-
-      agentScores.sort((a, b) => b.score - a.score);
-
-      const recommended = agentScores[0];
-      const alternatives = agentScores.slice(1, 4);
-
-      // Generate guidance
-      const guidance: string[] = [];
-      if (this.qeConfig.enableGuidance && detectedDomains.length > 0) {
-        const domainGuidance = getCombinedGuidance(detectedDomains[0], {
-          framework: request.context?.framework as any,
-          language: request.context?.language as any,
-          includeAntiPatterns: true,
-        });
-        guidance.push(...domainGuidance.slice(0, 5));
-      }
-
-      const latencyMs = performance.now() - startTime;
-      this.stats.totalRoutingLatency += latencyMs;
-      this.stats.routingLatencies.push(latencyMs);
-
-      // Keep only last 1000 latencies for P95 calculation
-      if (this.stats.routingLatencies.length > 1000) {
-        this.stats.routingLatencies.shift();
-      }
-
-      return ok({
-        recommendedAgent: recommended.agent,
-        confidence: recommended.score,
-        alternatives: alternatives.map(a => ({ agent: a.agent, score: a.score })),
-        domains: detectedDomains,
-        patterns,
-        guidance,
-        reasoning: recommended.reasoning.join('; '),
-        latencyMs,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Record pattern usage outcome
-   */
-  async recordOutcome(outcome: LearningOutcome): Promise<Result<void>> {
-    // Require explicit initialization - don't auto-initialize to avoid memory issues
-
-    if (!this.qeConfig.enableLearning) {
-      return ok(undefined);
-    }
-
-    try {
-      this.sqliteStore.recordUsage(
-        outcome.patternId,
-        outcome.success,
-        outcome.metrics,
-        outcome.feedback
-      );
-
-      this.stats.learningOutcomes++;
-      if (outcome.success) {
-        this.stats.successfulOutcomes++;
-      }
-
-      // Check if pattern should be promoted
-      const pattern = this.sqliteStore.getPattern(outcome.patternId);
-      if (pattern && this.shouldPromote(pattern)) {
-        this.sqliteStore.promotePattern(outcome.patternId);
-        console.log(`[RealQEReasoningBank] Pattern promoted to long-term: ${pattern.name}`);
-      }
-
-      return ok(undefined);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Check if pattern should be promoted to long-term
-   */
-  private shouldPromote(pattern: QEPattern): boolean {
-    return (
-      pattern.tier === 'short-term' &&
-      pattern.successfulUses >= 3 &&
-      pattern.successRate >= 0.7 &&
-      pattern.confidence >= 0.6
-    );
-  }
-
-  /**
-   * Get QE guidance for a domain
-   */
-  getQEGuidance(domain: QEDomain): QEGuidance {
-    return getGuidance(domain);
-  }
-
-  /**
-   * Generate guidance context
-   */
-  generateQEContext(
-    domain: QEDomain,
-    context?: { framework?: string; language?: string }
-  ): string {
-    return generateGuidanceContext(domain, context as any || {});
-  }
-
-  /**
-   * Check for anti-patterns
-   */
-  checkQEAntiPatterns(domain: QEDomain, content: string) {
-    return checkAntiPatterns(domain, content);
-  }
-
-  /**
-   * Get REAL statistics with REAL metrics
-   */
-  async getQEStats(): Promise<RealQEReasoningBankStats> {
-    // Require explicit initialization - don't auto-initialize to avoid memory issues
-
-    const sqliteStats = this.sqliteStore.getStats();
-
-    // Calculate P95 latency
-    const sortedLatencies = [...this.stats.routingLatencies].sort((a, b) => a - b);
-    const p95Index = Math.floor(sortedLatencies.length * 0.95);
-    const p95Latency = sortedLatencies[p95Index] || 0;
-
-    const byDomain: Record<QEDomain, number> = {} as Record<QEDomain, number>;
-    for (const domain of QE_DOMAIN_LIST) {
-      byDomain[domain] = sqliteStats.byDomain[domain] || 0;
-    }
-
-    return {
-      totalPatterns: sqliteStats.totalPatterns,
-      byDomain,
-      byTier: sqliteStats.byTier,
-      routingRequests: this.stats.routingRequests,
-      avgRoutingLatencyMs: this.stats.routingRequests > 0
-        ? this.stats.totalRoutingLatency / this.stats.routingRequests
-        : 0,
-      p95RoutingLatencyMs: p95Latency,
-      learningOutcomes: this.stats.learningOutcomes,
-      patternSuccessRate: this.stats.learningOutcomes > 0
-        ? this.stats.successfulOutcomes / this.stats.learningOutcomes
-        : 0,
-      embeddingCacheSize: 0, // Would need to track this in real-embeddings
-      transformerAvailable: isTransformerAvailable(),
-      embeddingDimension: getEmbeddingDimension(),
-      sqliteDbPath: this.qeConfig.sqlite.dbPath || '.agentic-qe/qe-patterns.db',
-    };
-  }
-
-  // ============================================================================
-  // Feedback Loop Methods (ADR-023)
-  // ============================================================================
-
-  /**
-   * Record a pattern outcome for feedback learning
-   */
-  async recordPatternOutcome(
-    patternId: string,
-    success: boolean,
-    qualityScore: number
-  ): Promise<void> {
-    const pattern = this.sqliteStore.getPattern(patternId);
-    if (!pattern) return;
-
-    // Calculate updated metrics (pattern properties are readonly, so we compute new values)
-    const newUsageCount = pattern.usageCount + 1;
-    const newSuccessfulUses = success ? pattern.successfulUses + 1 : pattern.successfulUses;
-
-    // Update success rate (rolling average)
-    const newSuccessRate = newSuccessfulUses / newUsageCount;
-
-    // Update quality score (exponential moving average)
-    const alpha = 0.3; // Weight for new observation
-    const newQualityScore = (1 - alpha) * pattern.qualityScore + alpha * qualityScore;
-
-    // Update confidence
-    const newConfidence = Math.min(1.0, 0.5 + (newUsageCount * 0.05) + (newSuccessRate * 0.3));
-
-    // Persist updates
-    this.sqliteStore.updatePattern(patternId, {
-      usageCount: newUsageCount,
-      successfulUses: newSuccessfulUses,
-      successRate: newSuccessRate,
-      qualityScore: newQualityScore,
-      confidence: newConfidence,
-    });
-  }
-
-  /**
-   * Check if a pattern should be promoted
-   */
-  async checkPatternPromotion(
-    patternId: string,
-    successCount: number,
-    successRate: number,
-    avgQuality: number
-  ): Promise<boolean> {
-    const pattern = this.sqliteStore.getPattern(patternId);
-    if (!pattern) return false;
-
-    // Promotion criteria
-    if (pattern.tier === 'short-term') {
-      return successCount >= 3 && successRate >= 0.6 && avgQuality >= 0.5;
-    } else if (pattern.tier === 'long-term') {
-      // Long-term patterns need higher thresholds to indicate they should be kept
-      return successCount >= 10 && successRate >= 0.75 && avgQuality >= 0.7;
-    }
-
-    return false;
-  }
-
-  /**
-   * Promote a pattern to the next tier
-   */
-  async promotePattern(patternId: string): Promise<void> {
-    this.sqliteStore.promotePattern(patternId);
-  }
-
-  /**
-   * Demote a pattern to a lower tier
-   */
-  async demotePattern(patternId: string): Promise<void> {
-    const pattern = this.sqliteStore.getPattern(patternId);
-    if (!pattern) return;
-
-    const tierOrder: Array<'short-term' | 'working' | 'long-term'> = ['short-term', 'working', 'long-term'];
-    const currentIndex = tierOrder.indexOf(pattern.tier as any);
-
-    if (currentIndex > 0) {
-      const newTier = tierOrder[currentIndex - 1];
-      this.sqliteStore.updatePattern(patternId, { tier: newTier });
-      console.log(`[RealQEReasoningBank] Pattern demoted to ${newTier}: ${pattern.name}`);
-    }
-  }
-
-  /**
-   * Dispose and cleanup
-   */
-  async dispose(): Promise<void> {
-    this.sqliteStore.close();
-    clearEmbeddingCache();
-    this.hnswIndex = null;
-    this.patternIdMap.clear();
-    this.initialized = false;
-    console.log('[RealQEReasoningBank] Disposed');
-  }
-}
-
-// Type definition for HNSW (hnswlib-node)
-interface HierarchicalNSW {
-  initIndex(maxElements: number, M: number, efConstruction: number): void;
-  setEf(ef: number): void;
-  addPoint(point: number[], label: number): void;
-  searchKnn(query: number[], k: number): { neighbors: number[]; distances: number[] };
-  getCurrentCount(): number;
-}
-
-/**
- * Create a Real QE ReasoningBank
- */
-export function createRealQEReasoningBank(
-  config: Partial<RealQEReasoningBankConfig> = {}
-): RealQEReasoningBank {
-  return new RealQEReasoningBank(config);
-}