agentic-qe 3.9.17 → 3.9.19

package/dist/init/phases/07-hooks.js

@@ -439,7 +439,7 @@ if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result)
                 },
                 // Task routing
                 {
-                    matcher: '^Task$',
+                    matcher: '^(Task|Agent)$',
                     hooks: [
                         {
                             type: 'command',
@@ -474,7 +474,7 @@ if (process.argv.includes('--json')) process.stdout.write(JSON.stringify(result)
                     ],
                 },
                 {
-                    matcher: '^Task$',
+                    matcher: '^(Task|Agent)$',
                     hooks: [
                         {
                             type: 'command',

package/dist/integrations/ruvector/hypergraph-engine.js

@@ -13,6 +13,7 @@
  *
  * @see /docs/plans/GOAP-V3-RUVECTOR-NEURAL-BACKBONE.md
  */
+import * as nodePath from 'node:path';
 import { v4 as uuidv4 } from 'uuid';
 import { HypergraphSchemaManager, nodeToRow, rowToNode, edgeToRow, rowToEdge, generateEdgeId, } from './hypergraph-schema.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
@@ -515,8 +516,13 @@ export class HypergraphEngine {
                     });
                 }
             }
-            // Phase 2: Create entity nodes
+            // Phase 2: Create entity nodes + a `contains` edge from the file node
+            // to each entity node. Without the contains edge, hypergraph_edges only
+            // ever held import edges from Phase 3 — `findUntestedFunctions`,
+            // `findImpactedTests`, and `findCoverageGaps` all returned empty
+            // regardless of indexing activity.
             for (const file of indexResult.files) {
+                const fileNodeId = `file:${file.path}`;
                 for (const entity of file.entities) {
                     try {
                         const entityId = `${entity.type}:${file.path}:${entity.name}`;
@@ -540,6 +546,21 @@ export class HypergraphEngine {
               `).run(entityId, nodeType, entity.name, file.path, entity.lineStart, entity.lineEnd, entity.complexity, entity.coverage);
                             nodesCreated++;
                         }
+                        // file → entity contains edge (idempotent via INSERT OR REPLACE)
+                        try {
+                            const containsEdgeId = generateEdgeId(fileNodeId, entityId, 'contains');
+                            this.config.db.prepare(`
+                INSERT OR REPLACE INTO hypergraph_edges (id, source_id, target_id, type, weight)
+                VALUES (?, ?, ?, 'contains', 1.0)
+              `).run(containsEdgeId, fileNodeId, entityId);
+                            edgesCreated++;
+                        }
+                        catch (edgeError) {
+                            errors.push({
+                                entity: `contains:${entity.type}:${entity.name}`,
+                                error: toErrorMessage(edgeError),
+                            });
+                        }
                     }
                     catch (entityError) {
                         errors.push({
@@ -550,13 +571,50 @@ export class HypergraphEngine {
                 }
             }
             // Phase 3: Create import edges (now all file nodes exist)
+            // Resolves relative paths against the source file's directory and probes
+            // common TS/JS/Python extensions (and `/index.ext` for directory imports)
+            // so internal imports map to existing hypergraph_nodes. Without this
+            // resolver, relative imports never matched any node and 0 edges were
+            // ever persisted from intra-repo imports.
+            const RESOLVE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.py', '.mjs', '.cjs'];
+            const RESOLVE_INDEX_FILES = [
+                '/index.ts', '/index.tsx', '/index.js', '/index.jsx', '/index.py',
+            ];
             for (const file of indexResult.files) {
                 const fileId = `file:${file.path}`;
                 for (const importPath of file.imports) {
                     try {
-                        const targetId = `file:${importPath}`;
-                        // Check if target node exists (import may reference external module)
-                        const targetExists = this.config.db.prepare('SELECT id FROM hypergraph_nodes WHERE id = ?').get(targetId);
+                        // Resolve relative imports against the source file's directory
+                        let resolvedPath = importPath;
+                        if (importPath.startsWith('./') || importPath.startsWith('../')) {
+                            resolvedPath = nodePath.resolve(nodePath.dirname(file.path), importPath);
+                        }
+                        let targetId = `file:${resolvedPath}`;
+                        // Check if target node exists; probe extensions and /index.ext
+                        const lookup = this.config.db.prepare('SELECT id FROM hypergraph_nodes WHERE id = ?');
+                        let targetExists = lookup.get(targetId);
+                        if (!targetExists) {
+                            for (const ext of RESOLVE_EXTENSIONS) {
+                                const candidate = targetId + ext;
+                                const hit = lookup.get(candidate);
+                                if (hit) {
+                                    targetId = candidate;
+                                    targetExists = hit;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!targetExists) {
+                            for (const idxFile of RESOLVE_INDEX_FILES) {
+                                const candidate = targetId + idxFile;
+                                const hit = lookup.get(candidate);
+                                if (hit) {
+                                    targetId = candidate;
+                                    targetExists = hit;
+                                    break;
+                                }
+                            }
+                        }
                         if (targetExists) {
                             const edgeId = generateEdgeId(fileId, targetId, 'imports');
                             this.config.db.prepare(`
@@ -665,6 +723,7 @@ export class HypergraphEngine {
             tests: 0,
             depends_on: 0,
             covers: 0,
+            contains: 0,
         };
         for (const row of edgesByTypeRows) {
             if (row.type in edgesByType) {

package/dist/integrations/ruvector/hypergraph-schema.d.ts

@@ -17,9 +17,13 @@ import type { Database as DatabaseType } from 'better-sqlite3';
  */
 export type NodeType = 'function' | 'module' | 'test' | 'file' | 'class';
 /**
- * Valid edge types in the hypergraph
+ * Valid edge types in the hypergraph.
+ *
+ * - `contains`: file → entity (function/class/etc) containment edge.
+ *   Without this, `findUntestedFunctions`, `findImpactedTests`, and
+ *   `findCoverageGaps` return empty regardless of indexing activity.
  */
-export type EdgeType = 'calls' | 'imports' | 'tests' | 'depends_on' | 'covers';
+export type EdgeType = 'calls' | 'imports' | 'tests' | 'depends_on' | 'covers' | 'contains';
 /**
  * Represents a node in the hypergraph (code entity)
  */

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,