agentic-qe 3.9.18 → 3.9.20

package/dist/learning/dream/dream-engine.js

@@ -235,6 +235,14 @@ export class DreamEngine {
                 await this.persistence.initialize();
             }
             this.db = this.persistence.getDatabase();
+            // ADR-001 Option C: dynamic-import paths in checkAndTriggerDream() open
+            // a fresh handle that the hook/worker busy_timeout pragmas never reach.
+            // 60s patient timeout here keeps dream cycles from failing under WAL
+            // contention from MCP workers (was 71% failure rate observed).
+            try {
+                this.db.pragma('busy_timeout = 60000');
+            }
+            catch { /* fail-soft */ }
             // Migrate legacy schema: rename 'duration' → 'duration_ms' if needed
             this.migrateSchema();
             // Initialize concept graph (shares same unified persistence)

package/dist/learning/embed-and-insert-pattern.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pattern embedding helper — unifies the 3 memory.db `qe_patterns` writers
+ * per ADR-058 (embedding-locality).
+ *
+ * Three live writers in our codebase write to `qe_patterns`:
+ *
+ *   1. learning/sqlite-persistence.ts:497    SQLitePatternStore.storePattern (canonical)
+ *   2. cli/commands/hooks-handlers/hooks-dream-learning.ts                  (consolidateAgentPatterns)
+ *   3. workers/workers/learning-consolidation.ts                             (createPatternsFromCandidates)
+ *
+ * Only the canonical writer pairs the row with a `qe_pattern_embeddings` row
+ * via `computeRealEmbedding(text, qeConfig.embeddings)`. Writers 2 & 3
+ * historically bypassed embedding generation, producing "ghost" patterns that
+ * loaded with no vectors and stayed invisible to HNSW pattern recall.
+ *
+ * This helper provides the embedding side so any caller can compute and persist
+ * the embedding adjacent to its existing INSERT INTO qe_patterns. It is
+ * fail-soft (errors are logged at debug level and swallowed) — pattern row
+ * persistence must not regress when embedding computation fails.
+ */
+import type Database from 'better-sqlite3';
+import { type EmbeddingConfig } from './real-embeddings.js';
+/**
+ * Compute an embedding for a pattern (`name + description + tags`) and persist
+ * it to `qe_pattern_embeddings`. Caller is responsible for the matching
+ * `qe_patterns` row.
+ *
+ * @param db          - better-sqlite3 database handle (typically from UnifiedMemoryManager.getDatabase())
+ * @param patternId   - id of the pattern row this embedding belongs to
+ * @param name        - pattern name (the most semantic component)
+ * @param description - pattern description (optional)
+ * @param tags        - pattern tags (optional)
+ * @param config      - override embedding model/cache config (defaults to Xenova/all-MiniLM-L6-v2)
+ */
+export declare function ensurePatternEmbedding(db: Database.Database, patternId: string, name: string, description: string | undefined | null, tags: string[] | undefined | null, config?: Partial<EmbeddingConfig>): Promise<void>;
+//# sourceMappingURL=embed-and-insert-pattern.d.ts.map

package/dist/learning/embed-and-insert-pattern.js

@@ -0,0 +1,52 @@
+/**
+ * Pattern embedding helper — unifies the 3 memory.db `qe_patterns` writers
+ * per ADR-058 (embedding-locality).
+ *
+ * Three live writers in our codebase write to `qe_patterns`:
+ *
+ *   1. learning/sqlite-persistence.ts:497    SQLitePatternStore.storePattern (canonical)
+ *   2. cli/commands/hooks-handlers/hooks-dream-learning.ts                  (consolidateAgentPatterns)
+ *   3. workers/workers/learning-consolidation.ts                             (createPatternsFromCandidates)
+ *
+ * Only the canonical writer pairs the row with a `qe_pattern_embeddings` row
+ * via `computeRealEmbedding(text, qeConfig.embeddings)`. Writers 2 & 3
+ * historically bypassed embedding generation, producing "ghost" patterns that
+ * loaded with no vectors and stayed invisible to HNSW pattern recall.
+ *
+ * This helper provides the embedding side so any caller can compute and persist
+ * the embedding adjacent to its existing INSERT INTO qe_patterns. It is
+ * fail-soft (errors are logged at debug level and swallowed) — pattern row
+ * persistence must not regress when embedding computation fails.
+ */
+import { computeRealEmbedding, DEFAULT_EMBEDDING_CONFIG, } from './real-embeddings.js';
+/**
+ * Compute an embedding for a pattern (`name + description + tags`) and persist
+ * it to `qe_pattern_embeddings`. Caller is responsible for the matching
+ * `qe_patterns` row.
+ *
+ * @param db          - better-sqlite3 database handle (typically from UnifiedMemoryManager.getDatabase())
+ * @param patternId   - id of the pattern row this embedding belongs to
+ * @param name        - pattern name (the most semantic component)
+ * @param description - pattern description (optional)
+ * @param tags        - pattern tags (optional)
+ * @param config      - override embedding model/cache config (defaults to Xenova/all-MiniLM-L6-v2)
+ */
+export async function ensurePatternEmbedding(db, patternId, name, description, tags, config = {}) {
+    try {
+        const text = `${name ?? ''} ${description ?? ''} ${(tags ?? []).join(' ')}`.trim();
+        if (!text)
+            return;
+        const embedding = await computeRealEmbedding(text, config);
+        if (!embedding || embedding.length === 0)
+            return;
+        const buffer = Buffer.from(new Float32Array(embedding).buffer);
+        const fullConfig = { ...DEFAULT_EMBEDDING_CONFIG, ...config };
+        db.prepare(`INSERT OR REPLACE INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model)
+       VALUES (?, ?, ?, ?)`).run(patternId, buffer, embedding.length, fullConfig.modelName);
+    }
+    catch (error) {
+        // Non-fatal: pattern row already persisted; embedding can be backfilled later.
+        console.debug('[ensurePatternEmbedding] non-fatal:', error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=embed-and-insert-pattern.js.map

package/dist/learning/pattern-store.d.ts

@@ -238,6 +238,14 @@ export declare class PatternStore implements IPatternStore {
      * Internal HNSW initialization with timeout protection
      */
     private initializeHNSWInternal;
+    /**
+     * Load existing qe_pattern_embeddings into the active HNSW index.
+     *
+     * Shared between the unified-HNSW path (ADR-071) and the legacy fallback
+     * so both report a populated `vectorCount` after first init. Capped to
+     * `maxElements` to prevent boot timeout on large pattern stores.
+     */
+    private loadEmbeddingsIntoHNSW;
     /**
      * Lazily initialize the VectorDeltaTracker for embedding version history.
      * Returns null when the useDeltaEventSourcing feature flag is disabled.

package/dist/learning/pattern-store.js

@@ -238,6 +238,10 @@ export class PatternStore {
                     this.hnswIndex = new HnswLegacyBridge(adapter);
                     this.hnswAvailable = true;
                     console.log('[PatternStore] Using unified HNSW via HnswLegacyBridge (ADR-071)');
+                    // Load existing qe_pattern_embeddings into the unified bridge on
+                    // first init. Without this the unified path starts empty and
+                    // routing falls back to context-only matches.
+                    await this.loadEmbeddingsIntoHNSW();
                     return;
                 }
                 catch (bridgeError) {
@@ -262,46 +266,7 @@ export class PatternStore {
             await Promise.race([initPromise, timeoutPromise]);
             this.hnswAvailable = this.hnswIndex.isNativeAvailable();
             // Load existing embeddings from SQLite into HNSW index (capped to prevent timeout)
-            if (this.sqliteStore) {
-                try {
-                    const embeddings = this.sqliteStore.getAllEmbeddings();
-                    const maxBootstrap = this.config.hnsw.maxElements;
-                    let loaded = 0;
-                    for (const { patternId, embedding } of embeddings) {
-                        if (loaded >= maxBootstrap)
-                            break;
-                        if (!embedding || embedding.length !== this.config.embeddingDimension)
-                            continue;
-                        const pattern = this.patternCache.get(patternId);
-                        if (!pattern)
-                            continue;
-                        try {
-                            await this.hnswIndex.insert(patternId, embedding, {
-                                filePath: pattern.patternType,
-                                lineCoverage: pattern.confidence * 100,
-                                branchCoverage: pattern.qualityScore * 100,
-                                functionCoverage: 0,
-                                statementCoverage: 0,
-                                uncoveredLineCount: 0,
-                                uncoveredBranchCount: 0,
-                                riskScore: 1 - pattern.confidence,
-                                lastUpdated: Date.now(),
-                                totalLines: 0,
-                            });
-                            loaded++;
-                        }
-                        catch {
-                            // Duplicate or invalid — skip
-                        }
-                    }
-                    if (loaded > 0) {
-                        console.log(`[PatternStore] Loaded ${loaded} embeddings from SQLite into HNSW`);
-                    }
-                }
-                catch (error) {
-                    console.warn('[PatternStore] Failed to load SQLite embeddings into HNSW:', toErrorMessage(error));
-                }
-            }
+            await this.loadEmbeddingsIntoHNSW();
             console.log(`[PatternStore] HNSW lazy-initialized (native: ${this.hnswAvailable})`);
         }
         catch (error) {
@@ -310,6 +275,61 @@ export class PatternStore {
             this.hnswAvailable = false;
         }
     }
+    /**
+     * Load existing qe_pattern_embeddings into the active HNSW index.
+     *
+     * Shared between the unified-HNSW path (ADR-071) and the legacy fallback
+     * so both report a populated `vectorCount` after first init. Capped to
+     * `maxElements` to prevent boot timeout on large pattern stores.
+     */
+    async loadEmbeddingsIntoHNSW() {
+        if (!this.hnswIndex || !this.sqliteStore)
+            return;
+        try {
+            const embeddings = this.sqliteStore.getAllEmbeddings();
+            const maxBootstrap = this.config.hnsw.maxElements;
+            let loaded = 0;
+            let skipped = 0;
+            for (const { patternId, embedding } of embeddings) {
+                if (loaded >= maxBootstrap)
+                    break;
+                if (!embedding || embedding.length !== this.config.embeddingDimension) {
+                    skipped++;
+                    continue;
+                }
+                const pattern = this.patternCache.get(patternId);
+                if (!pattern) {
+                    skipped++;
+                    continue;
+                }
+                try {
+                    await this.hnswIndex.insert(patternId, embedding, {
+                        filePath: pattern.patternType,
+                        lineCoverage: pattern.confidence * 100,
+                        branchCoverage: pattern.qualityScore * 100,
+                        functionCoverage: 0,
+                        statementCoverage: 0,
+                        uncoveredLineCount: 0,
+                        uncoveredBranchCount: 0,
+                        riskScore: 1 - pattern.confidence,
+                        lastUpdated: Date.now(),
+                        totalLines: 0,
+                    });
+                    loaded++;
+                }
+                catch {
+                    // Duplicate or invalid — skip
+                    skipped++;
+                }
+            }
+            if (loaded > 0) {
+                console.log(`[PatternStore] Loaded ${loaded} embeddings into HNSW (skipped ${skipped})`);
+            }
+        }
+        catch (error) {
+            console.warn('[PatternStore] Failed to load SQLite embeddings into HNSW:', toErrorMessage(error));
+        }
+    }
     /**
      * Lazily initialize the VectorDeltaTracker for embedding version history.
      * Returns null when the useDeltaEventSourcing feature flag is disabled.
@@ -1103,9 +1123,12 @@ export class PatternStore {
             totalSuccess += pattern.successRate;
             count++;
         }
-        // Get HNSW stats only if already initialized (no lazy-load for stats)
-        const hnswStats = this.hnswIndex !== null
-            ? await this.hnswIndex.getStats()
+        // Lazy-init HNSW for stats so `aqe hooks stats --json` reflects actual
+        // vectorCount instead of pre-init zeros. Cost is bounded by ensureHNSW's
+        // 5s timeout plus the load-loop cap.
+        const hnsw = await this.ensureHNSW();
+        const hnswStats = hnsw !== null
+            ? await hnsw.getStats()
             : { nativeHNSW: false, vectorCount: 0, indexSizeBytes: 0, lazyLoaded: true };
         return {
             totalPatterns: this.patternCache.size,