agentic-qe 3.9.19 → 3.9.21

package/dist/domains/code-intelligence/coordinator.js

@@ -308,6 +308,26 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
                         if (codeIndexResult.files.length > 0) {
                             await this.hypergraph.buildFromIndexResult(codeIndexResult);
                             logger.info(`Hypergraph rebuilt from ${codeIndexResult.files.length} indexed files`);
+                            // Synthesize test-coverage shape so findUntestedFunctions /
+                            // findImpactedTests have data to read. buildFromIndexResult
+                            // only writes file/entity nodes, `contains` edges (Phase 2),
+                            // and `imports` edges (Phase 3) — none of which match the
+                            // `type='test'` + `type='covers'` filters those queries
+                            // require. The synthesizer re-tags test-shaped file nodes
+                            // and writes covers edges from each test file to the
+                            // functions in the source files it imports. (Issue #439 /
+                            // Jordi P220 follow-up.)
+                            try {
+                                const synth = await this.hypergraph.synthesizeTestCoverage();
+                                if (synth.testsTagged > 0 || synth.coversCreated > 0) {
+                                    logger.info(`Test coverage synthesized: tests_tagged=${synth.testsTagged} covers_created=${synth.coversCreated}`);
+                                }
+                            }
+                            catch (synthError) {
+                                // Non-fatal — hypergraph nodes/edges from buildFromIndexResult
+                                // remain useful for module-dependency queries.
+                                logger.warn(`Test coverage synthesis skipped: ${synthError instanceof Error ? synthError.message : synthError}`);
+                            }
                         }
                     }
                     catch (hgError) {

package/dist/integrations/agentic-flow/reasoning-bank/experience-replay.js

@@ -103,6 +103,88 @@ export class ExperienceReplay {
         this.prepareStatements();
         // Load embeddings into memory index
         await this.loadEmbeddingIndex();
+        // Backfill missing embeddings on captured_experiences. Hook-side INSERT
+        // paths (sources: cli-hook-post-command, patch-060-post-task, etc.)
+        // bypass storeExperience() and never call computeRealEmbedding(),
+        // leaving HNSW C cold. Fire-and-forget so init isn't blocked; cap=200
+        // per boot to bound work.
+        void (async () => {
+            try {
+                if (!this.db)
+                    return;
+                const ghosts = this.db.prepare(`
+          SELECT id, domain, task FROM captured_experiences
+          WHERE embedding IS NULL AND consolidated_into IS NULL
+          LIMIT 200
+        `).all();
+                if (ghosts.length === 0)
+                    return;
+                const updateStmt = this.db.prepare(`
+          UPDATE captured_experiences
+          SET embedding = ?, embedding_dimension = ?
+          WHERE id = ?
+        `);
+                let written = 0;
+                for (const row of ghosts) {
+                    const text = `${row.domain ?? ''}: ${row.task}`.slice(0, 512);
+                    const embedding = await computeRealEmbedding(text);
+                    const buf = Buffer.from(new Float32Array(embedding).buffer);
+                    updateStmt.run(buf, embedding.length, row.id);
+                    // Add to live HNSW so freshly-embedded rows are immediately searchable
+                    const hnswId = this.nextHnswId++;
+                    this.hnswIndex.addEmbedding({
+                        vector: embedding,
+                        dimension: 384,
+                        namespace: 'experiences',
+                        text: row.id,
+                        timestamp: Date.now(),
+                        quantization: 'none',
+                        metadata: {},
+                    }, hnswId);
+                    this.idToExperienceId.set(hnswId, row.id);
+                    this.experienceIdToHnswId.set(row.id, hnswId);
+                    written++;
+                }
+                console.log(`[ExperienceReplay] Backfilled ${written} captured_experiences embeddings`);
+            }
+            catch (err) {
+                console.warn('[ExperienceReplay] Embedding backfill failed:', err instanceof Error ? err.message : err);
+            }
+        })();
+        // Backfill missing embeddings on qe_trajectories. TrajectoryTracker.endTrajectory()
+        // writes embedding=NULL with no follow-up worker; hook-side trajectory inserts
+        // (cli-hook-post-task) also leave the column NULL. Without this, kNN over
+        // historical trajectories collapses to "no candidates" and ReasoningBank
+        // can't surface similar past runs. Fail-soft when embedding column is absent
+        // (TrajectoryTracker may not have run its schema migration yet).
+        void (async () => {
+            try {
+                if (!this.db)
+                    return;
+                const cols = this.db.prepare("PRAGMA table_info(qe_trajectories)").all();
+                if (!cols.some(c => c.name === 'embedding'))
+                    return;
+                const rows = this.db.prepare(`
+          SELECT id, domain, task FROM qe_trajectories
+          WHERE embedding IS NULL AND ended_at IS NOT NULL
+          LIMIT 200
+        `).all();
+                if (rows.length === 0)
+                    return;
+                const updateStmt = this.db.prepare(`UPDATE qe_trajectories SET embedding = ? WHERE id = ?`);
+                let written = 0;
+                for (const row of rows) {
+                    const text = `${row.domain ?? ''}: ${row.task}`.slice(0, 512);
+                    const embedding = await computeRealEmbedding(text);
+                    updateStmt.run(Buffer.from(new Float32Array(embedding).buffer), row.id);
+                    written++;
+                }
+                console.log(`[ExperienceReplay] Backfilled ${written} qe_trajectories embeddings`);
+            }
+            catch (err) {
+                console.warn('[ExperienceReplay] Trajectory embedding backfill failed:', err instanceof Error ? err.message : err);
+            }
+        })();
         // Initialize reservoir buffer if feature flag is enabled (R10, ADR-087)
         if (getRuVectorFeatureFlags().useReservoirReplay) {
             this.reservoirBuffer = new ReservoirReplayBuffer({ capacity: 10_000 });

package/dist/integrations/embeddings/index/HNSWIndex.js

@@ -9,10 +9,18 @@
  *
  * @module integrations/embeddings/index/HNSWIndex
  */
-// ESM/CJS interop: hnswlib-node is CommonJS, we import via default export
-// This pattern matches real-qe-reasoning-bank.ts for consistency
-import hnswlib from 'hnswlib-node';
-const { HierarchicalNSW } = hnswlib;
+let cachedHnswlibCtor = null;
+function loadHnswlibConstructor() {
+    if (cachedHnswlibCtor)
+        return cachedHnswlibCtor;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require('hnswlib-node');
+    if (!mod.HierarchicalNSW) {
+        throw new Error('hnswlib-node module missing HierarchicalNSW export');
+    }
+    cachedHnswlibCtor = mod.HierarchicalNSW;
+    return cachedHnswlibCtor;
+}
 // ADR-071 Phase 2C: Always use unified HnswAdapter backend.
 // The hnswlib-node legacy path below is retained as dead code for
 // emergency rollback only — production always takes the adapter path.
@@ -86,7 +94,8 @@ export class HNSWEmbeddingIndex {
             'dotproduct': 'ip',
         };
         const space = spaceMap[this.config.metric] || 'cosine';
-        const index = new HierarchicalNSW(space, this.config.dimension);
+        const HierarchicalNSWCtor = loadHnswlibConstructor();
+        const index = new HierarchicalNSWCtor(space, this.config.dimension);
         index.initIndex({
             maxElements: 10000,
             m: this.config.M,
@@ -221,7 +230,8 @@ export class HNSWEmbeddingIndex {
             'dotproduct': 'ip',
         };
         const space = spaceMap[this.config.metric] || 'cosine';
-        const index = new HierarchicalNSW(space, this.config.dimension);
+        const HierarchicalNSWCtor = loadHnswlibConstructor();
+        const index = new HierarchicalNSWCtor(space, this.config.dimension);
         await index.readIndex(path);
         this.indexes.set(namespace, index);
         this.initialized.add(namespace);

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

@@ -348,6 +348,51 @@ export declare class HypergraphEngine {
     getStats(): Promise<HypergraphStats>;
     private ensureInitialized;
     private mapEntityTypeToNodeType;
+    /**
+     * Synthesize test-coverage edges from existing index state.
+     *
+     * Closes the gap that left `findUntestedFunctions`/`findImpactedTests`
+     * blind on every project (issue #439 / Jordi P220 follow-up). The shape
+     * of the gap was: those queries filter on `type='test'` source nodes and
+     * `type='covers'` edges, but `buildFromIndexResult` only ever wrote
+     * `type='file'` nodes and `imports`/`contains` edges. Result: empty
+     * answers regardless of indexing activity.
+     *
+     * This synthesis runs as a post-step over what `buildFromIndexResult`
+     * already produced:
+     *
+     *   1. **Tag test files.** Re-type any file node whose path matches a
+     *      test naming pattern (`.test.ts`, `.spec.ts`, `_test.py`, …) from
+     *      `'file'` to `'test'`. Idempotent — re-tagging a node already
+     *      typed `'test'` is a no-op. Existing-file UPDATEs in Phase 1 of
+     *      `buildFromIndexResult` only touch `nodesUpdated++` counter (no
+     *      column UPDATE), so the `'test'` tag survives subsequent indexes.
+     *
+     *   2. **Synthesize `covers` edges.** For each test file, walk its
+     *      `imports` edges to find imported source files; for each source
+     *      file, walk its `contains` edges to find function entities; write
+     *      `INSERT OR REPLACE` `covers` edges from the test file to each
+     *      such function. This is a heuristic — Jest/Vitest projects
+     *      typically `import { Foo } from '../src/foo'` and exercise `Foo`'s
+     *      methods in `it(...)` blocks; we treat that import structure as
+     *      proxy evidence of coverage. A proper coverage harness (Istanbul/
+     *      c8 lcov ingest) would produce sharper edges, but those would
+     *      slot in via the same `covers` schema.
+     *
+     * Idempotent: repeated calls converge — `INSERT OR REPLACE` on the same
+     * edge id (`${testId}--covers-->${fnId}`) is a no-op for unchanged
+     * topology.
+     *
+     * @returns Counts: `testsTagged` (file→test re-types this call) and
+     *          `coversCreated` (covers-edge writes this call, including
+     *          replacements of existing rows).
+     */
+    synthesizeTestCoverage(opts?: {
+        testPathPatterns?: RegExp[];
+    }): Promise<{
+        testsTagged: number;
+        coversCreated: number;
+    }>;
 }
 /**
  * Create a new HypergraphEngine instance

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

@@ -767,7 +767,109 @@ export class HypergraphEngine {
         };
         return mapping[entityType] ?? 'function';
     }
+    /**
+     * Synthesize test-coverage edges from existing index state.
+     *
+     * Closes the gap that left `findUntestedFunctions`/`findImpactedTests`
+     * blind on every project (issue #439 / Jordi P220 follow-up). The shape
+     * of the gap was: those queries filter on `type='test'` source nodes and
+     * `type='covers'` edges, but `buildFromIndexResult` only ever wrote
+     * `type='file'` nodes and `imports`/`contains` edges. Result: empty
+     * answers regardless of indexing activity.
+     *
+     * This synthesis runs as a post-step over what `buildFromIndexResult`
+     * already produced:
+     *
+     *   1. **Tag test files.** Re-type any file node whose path matches a
+     *      test naming pattern (`.test.ts`, `.spec.ts`, `_test.py`, …) from
+     *      `'file'` to `'test'`. Idempotent — re-tagging a node already
+     *      typed `'test'` is a no-op. Existing-file UPDATEs in Phase 1 of
+     *      `buildFromIndexResult` only touch `nodesUpdated++` counter (no
+     *      column UPDATE), so the `'test'` tag survives subsequent indexes.
+     *
+     *   2. **Synthesize `covers` edges.** For each test file, walk its
+     *      `imports` edges to find imported source files; for each source
+     *      file, walk its `contains` edges to find function entities; write
+     *      `INSERT OR REPLACE` `covers` edges from the test file to each
+     *      such function. This is a heuristic — Jest/Vitest projects
+     *      typically `import { Foo } from '../src/foo'` and exercise `Foo`'s
+     *      methods in `it(...)` blocks; we treat that import structure as
+     *      proxy evidence of coverage. A proper coverage harness (Istanbul/
+     *      c8 lcov ingest) would produce sharper edges, but those would
+     *      slot in via the same `covers` schema.
+     *
+     * Idempotent: repeated calls converge — `INSERT OR REPLACE` on the same
+     * edge id (`${testId}--covers-->${fnId}`) is a no-op for unchanged
+     * topology.
+     *
+     * @returns Counts: `testsTagged` (file→test re-types this call) and
+     *          `coversCreated` (covers-edge writes this call, including
+     *          replacements of existing rows).
+     */
+    async synthesizeTestCoverage(opts) {
+        this.ensureInitialized();
+        const patterns = opts?.testPathPatterns ?? DEFAULT_TEST_PATH_PATTERNS;
+        let testsTagged = 0;
+        let coversCreated = 0;
+        const fileRows = this.config.db
+            .prepare(`SELECT id, file_path FROM hypergraph_nodes
+         WHERE type IN ('file', 'test') AND file_path IS NOT NULL`)
+            .all();
+        const testFileIds = [];
+        for (const row of fileRows) {
+            if (patterns.some((p) => p.test(row.file_path))) {
+                testFileIds.push(row.id);
+            }
+        }
+        if (testFileIds.length === 0) {
+            return { testsTagged: 0, coversCreated: 0 };
+        }
+        const tagStmt = this.config.db.prepare(`UPDATE hypergraph_nodes SET type = 'test', updated_at = datetime('now')
+       WHERE id = ? AND type = 'file'`);
+        const findImportsStmt = this.config.db.prepare(`SELECT target_id FROM hypergraph_edges
+       WHERE source_id = ? AND type = 'imports'`);
+        const findFunctionsStmt = this.config.db.prepare(`SELECT n.id AS id FROM hypergraph_nodes n
+       JOIN hypergraph_edges e ON e.target_id = n.id
+       WHERE e.source_id = ? AND e.type = 'contains' AND n.type = 'function'`);
+        const insertCoversStmt = this.config.db.prepare(`
+      INSERT OR REPLACE INTO hypergraph_edges (id, source_id, target_id, type, weight)
+      VALUES (?, ?, ?, 'covers', 1.0)
+    `);
+        const txn = this.config.db.transaction(() => {
+            for (const testId of testFileIds) {
+                // (1) Re-tag — only counts the first transition file→test.
+                const taggedRows = tagStmt.run(testId).changes;
+                if (taggedRows > 0)
+                    testsTagged++;
+                // (2) Walk imports → contains → write covers.
+                const importedFileIds = findImportsStmt.all(testId).map((r) => r.target_id);
+                for (const fileId of importedFileIds) {
+                    const functionIds = findFunctionsStmt.all(fileId).map((r) => r.id);
+                    for (const fnId of functionIds) {
+                        const edgeId = `${testId}--covers-->${fnId}`;
+                        insertCoversStmt.run(edgeId, testId, fnId);
+                        coversCreated++;
+                    }
+                }
+            }
+        });
+        txn();
+        return { testsTagged, coversCreated };
+    }
 }
+/**
+ * Test-file path patterns matched by {@link HypergraphEngine.synthesizeTestCoverage}.
+ * Mirrors `KnowledgeGraphService.isTestFile` so the two layers agree on what
+ * "looks like a test file" means.
+ */
+const DEFAULT_TEST_PATH_PATTERNS = [
+    /\.test\.[tj]sx?$/,
+    /\.spec\.[tj]sx?$/,
+    /_test\.[tj]sx?$/,
+    /test_.*\.py$/,
+    /.*_test\.py$/,
+    /.*_test\.go$/,
+];
 // ============================================================================
 // Factory Functions
 // ============================================================================

package/dist/integrations/ruvector/shared-rvf-adapter.js

@@ -26,14 +26,28 @@ export function getSharedRvfAdapter(dataDir = '.agentic-qe', dimensions = 384) {
     try {
         // Dynamic require to match the bundled build pattern used elsewhere
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { isRvfNativeAvailable, createRvfStore } = require('./rvf-native-adapter.js');
+        const { isRvfNativeAvailable, createRvfStore, openRvfStore } = require('./rvf-native-adapter.js');
         if (!isRvfNativeAvailable()) {
             console.warn('[RVF] Native bindings unavailable — agent branching and dream COW disabled. ' +
                 'Install @ruvector/rvf-node to enable.');
             return null;
         }
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
         const path = require('path');
-        sharedAdapter = createRvfStore(path.join(dataDir, 'patterns.rvf'), dimensions);
+        const rvfPath = path.join(dataDir, 'patterns.rvf');
+        // Open-or-create with a try-ladder rather than `existsSync` gate.
+        // Reasons:
+        //  1. RVF native's `RvfDatabase.create()` throws `0x0303 FsyncFailed`
+        //     when the target file already exists (verified against both 0.1.7
+        //     and 0.1.8 native binaries on linux-arm64). Earlier init phases
+        //     legitimately produce patterns.rvf, so subsequent CLI / MCP boot
+        //     would crash without this guard. (Jordi #439 / RUFLO P020.)
+        //  2. A bare `existsSync(...) ? open : create` is racy across
+        //     processes — two parallel `aqe` invocations during init can both
+        //     observe absent and both call `create`, with the second hitting
+        //     FsyncFailed regardless. The try-ladder degrades to whichever
+        //     path the OS actually permits.
+        sharedAdapter = openOrCreateRvf(openRvfStore, createRvfStore, rvfPath, dimensions);
         return sharedAdapter;
     }
     catch (error) {
@@ -41,6 +55,100 @@ export function getSharedRvfAdapter(dataDir = '.agentic-qe', dimensions = 384) {
         return null;
     }
 }
+/**
+ * Race-tolerant open-or-create.
+ * Tries open first (cheap, succeeds for the common case where init has
+ * already produced the file). On open failure we attempt create. On the
+ * concurrent-create loser, create itself fails with `FsyncFailed`; we
+ * retry open once more. Any final exception bubbles up to the caller.
+ *
+ * Also asserts `dim()` matches the caller-requested `dimensions` after
+ * open so silent dimension drift between releases / configs is detected
+ * — a bad-dim file is closed and create() is attempted (fail-loud rather
+ * than corrupt-silently, which would manifest as wrong vector hits later).
+ */
+function openOrCreateRvf(openFn, createFn, rvfPath, dimensions) {
+    const tryOpen = () => {
+        try {
+            return { adapter: openFn(rvfPath), err: null };
+        }
+        catch (err) {
+            return { adapter: null, err };
+        }
+    };
+    const isLockHeld = (err) => {
+        const m = err instanceof Error ? err.message : String(err);
+        return m.includes('LockHeld') || m.includes('0x0300');
+    };
+    // Pass 1: try to open whatever's there.
+    let { adapter: opened, err: openErr } = tryOpen();
+    // Pass 1.5: stale-lock recovery. The native binding writes a `<rvfPath>.lock`
+    // file on open and removes it on close. `aqe init` and short-lived CLI
+    // processes routinely exit without an explicit close, leaving a stale
+    // .lock that subsequent invocations interpret as `LockHeld`. Since AQE
+    // CLI is overwhelmingly single-shot serial, the realistic case is "the
+    // prior process is dead and the lock is stale". We unlink the .lock and
+    // retry open exactly once. If a genuinely-live peer existed, it still
+    // holds the file open — but the binding's lock is content-based (lock
+    // file presence), so this is a best-effort cooperative recovery rather
+    // than an OS-level lock break.
+    if (!opened && isLockHeld(openErr)) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const fs = require('fs');
+            const lockPath = `${rvfPath}.lock`;
+            if (fs.existsSync(lockPath)) {
+                fs.unlinkSync(lockPath);
+                console.warn(`[RVF] Removed stale lock file at ${lockPath} (prior process exited without closing). ` +
+                    'Retrying open. If you see this repeatedly under live concurrency, file an issue.');
+                ({ adapter: opened, err: openErr } = tryOpen());
+            }
+        }
+        catch (recoveryErr) {
+            // Lock removal failed (permissions?) — fall through to error path.
+            if (process.env.DEBUG) {
+                console.debug('[RVF] stale-lock recovery failed:', recoveryErr instanceof Error ? recoveryErr.message : recoveryErr);
+            }
+        }
+    }
+    if (opened) {
+        const actualDim = opened.dimension();
+        if (actualDim === dimensions)
+            return opened;
+        console.warn(`[RVF] patterns.rvf dimension mismatch: file=${actualDim} requested=${dimensions} — ` +
+            'closing and degrading. Delete the .rvf file to recreate at the requested dim.');
+        try {
+            opened.close();
+        }
+        catch { /* best-effort */ }
+        // Don't auto-recreate over a dim-mismatched file. Surface to caller via
+        // throw so getSharedRvfAdapter logs and returns null (degrade to SQLite).
+        throw new Error(`RVF dimension mismatch (file=${actualDim}, requested=${dimensions})`);
+    }
+    // Pass 2: open failed even after stale-lock recovery → try create.
+    try {
+        return createFn(rvfPath, dimensions);
+    }
+    catch (createErr) {
+        // Pass 3: create failed (likely FsyncFailed because a peer process won
+        // the race). Try open one more time.
+        try {
+            const reopened = openFn(rvfPath);
+            if (reopened.dimension() !== dimensions) {
+                try {
+                    reopened.close();
+                }
+                catch { /* best-effort */ }
+                throw new Error(`RVF dimension mismatch after race (file=${reopened.dimension()}, requested=${dimensions})`);
+            }
+            return reopened;
+        }
+        catch {
+            // Fall through with the more informative original error.
+            throw createErr instanceof Error ? createErr : new Error(String(createErr));
+        }
+    }
+}
 /** Close the shared adapter and reset the singleton. */
 export function resetSharedRvfAdapter() {
     if (sharedAdapter) {

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/pattern-store.js

@@ -1391,7 +1391,44 @@ export function createPatternStore(memory, config) {
                     // Shared adapter unavailable — fall back to direct create
                 }
                 if (!useSharedAdapter) {
-                    const store = new RvfPatternStore((path, dim) => _createRvfStore(path, dim), { rvfPath, base: mergedConfig });
+                    // Race-tolerant open-or-create with dim verification, mirroring
+                    // shared-rvf-adapter.ts. Bare `existsSync ? open : create` is
+                    // racy across processes (two parallel CLI invocations during init
+                    // both observe absent, second hits FsyncFailed regardless). Try
+                    // open first, fall back to create, retry open on create-race.
+                    // (Jordi #439 / RUFLO P020.)
+                    const store = new RvfPatternStore((path, dim) => {
+                        // eslint-disable-next-line @typescript-eslint/no-require-imports
+                        const { openRvfStore } = require('../integrations/ruvector/rvf-native-adapter.js');
+                        const tryOpen = () => {
+                            try {
+                                return openRvfStore(path);
+                            }
+                            catch {
+                                return null;
+                            }
+                        };
+                        let adapter = tryOpen();
+                        if (adapter) {
+                            if (adapter.dimension() !== dim) {
+                                try {
+                                    adapter.close();
+                                }
+                                catch { /* best-effort */ }
+                                throw new Error(`RVF dimension mismatch (file=${adapter.dimension()}, requested=${dim})`);
+                            }
+                            return adapter;
+                        }
+                        try {
+                            return _createRvfStore(path, dim);
+                        }
+                        catch (createErr) {
+                            adapter = tryOpen();
+                            if (adapter && adapter.dimension() === dim)
+                                return adapter;
+                            throw createErr;
+                        }
+                    }, { rvfPath, base: mergedConfig });
                     console.log('[PatternStore] Using RVF-backed store (ADR-066)');
                     return store;
                 }