agentic-qe 3.9.18 → 3.9.20

package/dist/cli/commands/hooks-handlers/hooks-shared.js

@@ -117,6 +117,30 @@ export async function initializeHooksSystem() {
         state.initialized = true;
     }
 }
+/**
+ * Hook-side busy_timeout (ADR-001 Option C / patch 260).
+ *
+ * Hooks fire from short-lived `npx aqe hooks ...` subprocesses. They open the
+ * shared memory.db while MCP-daemon workers may be holding the WAL write-lock
+ * for several seconds during dream-cycle / pattern-promotion. With the default
+ * 5s busy_timeout, hooks fail under contention. With 60s, they wait patiently
+ * — the hook subprocess exits as soon as it's done, so the longer timeout has
+ * no broader cost.
+ *
+ * Workers in MCP still use the platform default (5s) so they fail fast and
+ * retry on the next tick — they yield the lock to hooks under contention.
+ *
+ * This is per-connection: setting the pragma in a hook subprocess only affects
+ * that subprocess's connection, not the MCP daemon's.
+ */
+export function applyHookBusyTimeout(db) {
+    try {
+        db.pragma('busy_timeout = 60000');
+    }
+    catch {
+        // No-op if pragma fails (mocked DBs in tests, etc.)
+    }
+}
 /**
  * Create hybrid backend with timeout protection
  *
@@ -126,13 +150,21 @@ export async function initializeHooksSystem() {
 export async function createHybridBackendWithTimeout(dataDir) {
     const timeoutMs = 5000;
     // ADR-046: Use unified memory.db path - same as all other components
-    // HybridMemoryBackend is a facade over UnifiedMemoryManager
+    // HybridMemoryBackend is a facade over UnifiedMemoryManager.
+    //
+    // ADR-001 Option C / patch 260: hooks open with a 60s busy_timeout so they
+    // wait patiently through worker bursts (dream-cycle / pattern-promotion
+    // can hold the WAL write-lock for several seconds). Hooks fire from a
+    // short-lived `npx aqe hooks ...` process — our 60s timeout here only
+    // affects the hook process; the MCP daemon's worker connections inherit
+    // the platform default (5s) so they fail fast and retry next tick,
+    // yielding the lock to hooks under contention.
     const backend = new HybridMemoryBackend({
         sqlite: {
             path: path.join(dataDir, 'memory.db'), // ADR-046: Unified storage
             walMode: true,
             poolSize: 3,
-            busyTimeout: 5000,
+            busyTimeout: 60000,
         },
         // agentdb.path is ignored - vectors stored in unified memory.db
         enableFallback: true,
@@ -220,5 +252,5 @@ export function printGuidance(guidance) {
 // ============================================================================
 // Dream Scheduler & Learning — re-exported from hooks-dream-learning.ts
 // ============================================================================
-export { DREAM_STATE_KEY, DREAM_INTERVAL_MS, DREAM_EXPERIENCE_THRESHOLD, DREAM_MIN_GAP_MS, checkAndTriggerDream, incrementDreamExperience, persistCommandExperience, consolidateExperiencesToPatterns, } from './hooks-dream-learning.js';
+export { DREAM_STATE_KEY, DREAM_INTERVAL_MS, DREAM_EXPERIENCE_THRESHOLD, DREAM_MIN_GAP_MS, checkAndTriggerDream, incrementDreamExperience, persistCommandExperience, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, consolidateExperiencesToPatterns, } from './hooks-dream-learning.js';
 //# sourceMappingURL=hooks-shared.js.map

package/dist/cli/commands/hooks-handlers/routing-hooks.js

@@ -8,7 +8,7 @@ import { randomUUID } from 'crypto';
 import chalk from 'chalk';
 import path from 'node:path';
 import { findProjectRoot } from '../../../kernel/unified-memory.js';
-import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, printJson, printError, printGuidance, } from './hooks-shared.js';
+import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, printJson, printError, printGuidance, } from './hooks-shared.js';
 /**
  * Read piped stdin with a short timeout. Claude Code delivers
  * UserPromptSubmit / PostToolUse / etc. events as JSON on stdin —
@@ -147,7 +147,15 @@ export function registerRoutingHooks(hooks) {
                     await um.initialize();
                 }
                 const db = um.getDatabase();
+                applyHookBusyTimeout(db);
                 const outcomeId = `route-${Date.now()}-${randomUUID().slice(0, 8)}`;
+                // Split-write semantics: quality_score means "outcome quality after
+                // task ran" (6-dim formula), NOT routing confidence. Routing-
+                // confidence stays in decision_json. We write a sentinel
+                // (success=0, quality_score=-1) so post-task UPDATE fills the actual
+                // quality. lowConfidence is surfaced via decision_json + the error
+                // column so it's visible in queries that don't parse JSON.
+                const lowConfidence = routing.confidence < 0.5;
                 db.prepare(`
             INSERT OR REPLACE INTO routing_outcomes (
               id, task_json, decision_json, used_agent,
@@ -158,10 +166,12 @@ export function registerRoutingHooks(hooks) {
                     recommended: routing.recommendedAgent,
                     confidence: routing.confidence,
                     alternatives: routing.alternatives,
-                }), routing.recommendedAgent, 1, // followed_recommendation = true (recommendation stage)
-                1, // success = true (routing itself succeeded)
-                routing.confidence, 0, // duration not tracked at routing stage
-                null);
+                    lowConfidence,
+                }), routing.recommendedAgent, 1, // followed_recommendation = true
+                0, // success = 0 (sentinel — post-task UPDATEs)
+                -1, // quality_score = -1 sentinel
+                0, // duration not yet tracked
+                lowConfidence ? 'low-confidence' : null);
                 // Increment dream experience counter
                 const projectRoot = findProjectRoot();
                 const dataDir = path.join(projectRoot, '.agentic-qe');

package/dist/cli/commands/hooks-handlers/task-hooks.js

@@ -4,11 +4,52 @@
  *
  * Handles task lifecycle hooks for pattern learning.
  */
+import { createHash, randomUUID } from 'node:crypto';
 import chalk from 'chalk';
 import path from 'node:path';
 import { QE_HOOK_EVENTS } from '../../../learning/qe-hooks.js';
-import { findProjectRoot } from '../../../kernel/unified-memory.js';
-import { getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, checkAndTriggerDream, printJson, printSuccess, } from './hooks-shared.js';
+import { findProjectRoot, getUnifiedMemory } from '../../../kernel/unified-memory.js';
+import { applyHookBusyTimeout, getHooksSystem, createHybridBackendWithTimeout, incrementDreamExperience, checkAndTriggerDream, persistTaskOutcome, updateHookRouterQValue, updateRoutingOutcomeQuality, printJson, printSuccess, } from './hooks-shared.js';
+// ============================================================================
+// Constants — task-bridge / routing-quality / q-learning
+// ============================================================================
+/** kv_store namespace key for cross-subprocess pre-task → post-task bridge */
+const TASK_BRIDGE_NAMESPACE = 'task-bridge';
+/** Bridge TTL: a Task() invocation rarely exceeds this — older entries are stale */
+const TASK_BRIDGE_TTL_MS = 600_000; // 10 minutes
+/** Confidence floor below which we flag the route as low-confidence (patch 320) */
+const LOW_CONFIDENCE_THRESHOLD = 0.5;
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Derive a structural taskType from a free-form task description.
+ * Mirrors the categories the q-learning router cares about (ADR-061/087).
+ */
+function deriveTaskType(description) {
+    const d = description.toLowerCase();
+    if (/\bgenerate[- ]?test|\btest[- ]?gen|\bgenerate.+spec/.test(d))
+        return 'test-generation';
+    if (/\bcoverage|\banalyze.+cover/.test(d))
+        return 'coverage-analysis';
+    if (/\bquality|\bassess|\baudit/.test(d))
+        return 'quality-assessment';
+    if (/\bsecurity|\bvulnerab|\bcompliance/.test(d))
+        return 'security-compliance';
+    if (/\bdefect|\bbug|\bdiagnos/.test(d))
+        return 'defect-intelligence';
+    if (/\brequirement|\bspec\b/.test(d))
+        return 'requirements-validation';
+    if (/\brefactor|\brewrite|\boptim/.test(d))
+        return 'refactoring';
+    if (/\btest|\brun.+test/.test(d))
+        return 'test-execution';
+    return 'unknown';
+}
+/** Hash a description to a stable short bridge key. */
+function hashDescription(description) {
+    return createHash('sha256').update(description).digest('hex').slice(0, 16);
+}
 /**
  * Register pre-task and post-task subcommands on the hooks command.
  */
@@ -35,6 +76,132 @@ export function registerTaskHooks(hooks) {
                     routing = result.value;
                 }
             }
+            // Patch 050: top-5 selectedPatternIds for downstream per-pattern feedback
+            const selectedPatternIds = (routing?.patterns ?? [])
+                .slice(0, 5)
+                .map((p) => p?.id)
+                .filter((id) => typeof id === 'string');
+            // Patches 090/100/160/300/320: signals derived from memory.db.
+            // All best-effort: failures fall through to empty/default values.
+            let historicalBest = null;
+            let priorVerdicts = [];
+            let estimatedTokenSavings = 0;
+            let bridgeKey = null;
+            try {
+                const um = getUnifiedMemory();
+                if (!um.isInitialized()) {
+                    await um.initialize();
+                }
+                const db = um.getDatabase();
+                applyHookBusyTimeout(db);
+                // Patch 090: best-historical-agent across past successful routes
+                try {
+                    const row = db.prepare(`
+              SELECT used_agent AS agent,
+                     ROUND(AVG(quality_score), 3) AS avgQuality,
+                     COUNT(*) AS n
+              FROM routing_outcomes
+              WHERE success = 1 AND quality_score >= 0
+              GROUP BY used_agent
+              ORDER BY avgQuality DESC, n DESC
+              LIMIT 1
+            `).get();
+                    if (row)
+                        historicalBest = row;
+                }
+                catch { /* table may be empty */ }
+                // Patch 100: surface recent verdicts namespace for context reuse
+                try {
+                    const rows = db.prepare(`
+              SELECT key, value
+              FROM kv_store
+              WHERE namespace = 'verdicts'
+                AND created_at > datetime('now', '-7 days')
+              ORDER BY created_at DESC
+              LIMIT 3
+            `).all();
+                    priorVerdicts = rows.map((r) => ({
+                        key: r.key,
+                        summary: String(r.value).slice(0, 200),
+                    }));
+                }
+                catch { /* table may be empty */ }
+                // Patch 300: bootstrap estimatedTokenSavings from selected patterns
+                if (selectedPatternIds.length > 0) {
+                    try {
+                        const placeholders = selectedPatternIds.map(() => '?').join(',');
+                        const tokRow = db.prepare(`
+                SELECT COALESCE(SUM(average_token_savings), 0) AS sum
+                FROM qe_patterns
+                WHERE id IN (${placeholders})
+              `).get(...selectedPatternIds);
+                        estimatedTokenSavings = Math.max(0, Math.round(tokRow?.sum ?? 0));
+                    }
+                    catch { /* column may not exist on older schemas */ }
+                }
+                // Patch 160 + 280-bridge: write the task-bridge entry that post-task
+                // will consume to fan out experience_applications per pattern_id and
+                // derive a structural q-learning state_key.
+                if (options.description && selectedPatternIds.length > 0) {
+                    try {
+                        const description = String(options.description);
+                        const taskType = deriveTaskType(description);
+                        const priority = 'normal';
+                        const domain = routing?.domains?.[0] ?? 'any';
+                        const complexityBucket = Math.max(0, Math.min(10, Math.round(Math.min(description.length / 200, 1) * 10)));
+                        bridgeKey = `task:${hashDescription(description)}`;
+                        const payload = JSON.stringify({
+                            selectedPatternIds,
+                            agent: routing?.recommendedAgent ?? null,
+                            description: description.slice(0, 200),
+                            taskType,
+                            priority,
+                            domain,
+                            complexityBucket,
+                            estimatedTokenSavings,
+                            ts: Date.now(),
+                        });
+                        const expiresAt = Date.now() + TASK_BRIDGE_TTL_MS;
+                        db.prepare(`
+                INSERT OR REPLACE INTO kv_store (key, namespace, value, expires_at, created_at)
+                VALUES (?, ?, ?, ?, strftime('%s','now')*1000)
+              `).run(bridgeKey, TASK_BRIDGE_NAMESPACE, payload, expiresAt);
+                    }
+                    catch (bridgeErr) {
+                        console.error(chalk.dim(`[hooks] pre-task bridge: ${bridgeErr instanceof Error ? bridgeErr.message : 'unknown'}`));
+                    }
+                }
+                // Patch 150: write a routing_outcomes sentinel that post-task UPDATEs
+                // with the 6-dim outcome quality. Pre-task cannot know quality yet.
+                // success=0/quality=-1 sentinel pair makes the row easy to find later.
+                if (routing?.recommendedAgent && options.taskId) {
+                    try {
+                        const outcomeId = `route-${Date.now()}-${randomUUID().slice(0, 8)}`;
+                        const lowConfidence = routing.confidence < LOW_CONFIDENCE_THRESHOLD;
+                        db.prepare(`
+                INSERT INTO routing_outcomes (
+                  id, task_json, decision_json, used_agent,
+                  followed_recommendation, success, quality_score,
+                  duration_ms, error
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+              `).run(outcomeId, JSON.stringify({ description: options.description, taskId: options.taskId }), JSON.stringify({
+                            recommended: routing.recommendedAgent,
+                            confidence: routing.confidence,
+                            alternatives: routing.alternatives,
+                            lowConfidence,
+                        }), routing.recommendedAgent, 1, 0, // success = 0 (sentinel — post-task UPDATEs to actual)
+                        -1, // quality_score = -1 sentinel
+                        0, lowConfidence ? 'low-confidence' : null);
+                    }
+                    catch (sentinelErr) {
+                        console.error(chalk.dim(`[hooks] pre-task sentinel: ${sentinelErr instanceof Error ? sentinelErr.message : 'unknown'}`));
+                    }
+                }
+            }
+            catch (memErr) {
+                console.error(chalk.dim(`[hooks] pre-task memory: ${memErr instanceof Error ? memErr.message : 'unknown'}`));
+            }
+            const lowConfidence = routing ? routing.confidence < LOW_CONFIDENCE_THRESHOLD : false;
             if (options.json) {
                 printJson({
                     success: true,
@@ -43,6 +210,18 @@ export function registerTaskHooks(hooks) {
                     recommendedAgent: routing?.recommendedAgent,
                     confidence: routing?.confidence,
                     guidance: routing?.guidance || [],
+                    // Patch 050
+                    selectedPatternIds,
+                    // Patch 090
+                    historicalBest,
+                    // Patch 100
+                    priorVerdicts,
+                    // Patch 300
+                    estimatedTokenSavings,
+                    // Patch 320
+                    lowConfidence,
+                    // Bridge identifier so post-task can correlate (debug aid)
+                    bridgeKey,
                 });
             }
             else {
@@ -51,6 +230,9 @@ export function registerTaskHooks(hooks) {
                 if (routing) {
                     console.log(chalk.bold('\n🎯 Recommended:'), chalk.cyan(routing.recommendedAgent));
                     console.log(chalk.dim(`  Confidence: ${(routing.confidence * 100).toFixed(1)}%`));
+                    if (lowConfidence) {
+                        console.log(chalk.yellow('  ⚠  Low confidence — consider providing more context'));
+                    }
                 }
             }
             return;
@@ -95,14 +277,43 @@ export function registerTaskHooks(hooks) {
                 // Record as learning experience for every post-task invocation
                 if (options.taskId) {
                     const agent = options.agent || 'unknown';
+                    const durationMs = options.duration ? parseInt(options.duration, 10) : 0;
                     await reasoningBank.recordOutcome({
                         patternId: `task:${agent}:${options.taskId}`,
                         success,
-                        metrics: {
-                            executionTimeMs: options.duration ? parseInt(options.duration, 10) : 0,
-                        },
+                        metrics: { executionTimeMs: durationMs },
                         feedback: `Agent: ${agent}, Task: ${options.taskId}`,
                     });
+                    // Stream B: full experience pipeline (captured_experiences,
+                    // experience_applications + per-pattern fan-out, qe_trajectories
+                    // single-step + multi-step stitch, dream_insights.applied bump).
+                    // Patches 060/110/120/160/180/300.
+                    const outcome = await persistTaskOutcome({
+                        taskId: options.taskId,
+                        agent,
+                        durationMs,
+                        success,
+                    });
+                    // Stream D (patch 150): apply 6-dim outcome quality to the
+                    // routing_outcomes sentinel that pre-task wrote with quality=-1.
+                    await updateRoutingOutcomeQuality({
+                        agent,
+                        success,
+                        durationMs,
+                        qualityScore: outcome.qualityScore,
+                    });
+                    // Stream F (patch 280): Bellman Q-update for the hook-router state.
+                    // Bridge payload carries the structural state derivation.
+                    if (outcome.bridge) {
+                        await updateHookRouterQValue({
+                            taskType: outcome.bridge.taskType,
+                            priority: outcome.bridge.priority,
+                            domain: outcome.bridge.domain,
+                            complexityBucket: outcome.bridge.complexityBucket,
+                            agent,
+                            success,
+                        });
+                    }
                 }
                 // Record experience for dream scheduler and check if dream should trigger
                 const projectRoot = findProjectRoot();

package/dist/cli/commands/init.js

@@ -248,7 +248,9 @@ async function runReset(options) {
         path.join(projectRoot, '.claude', 'settings.json'),
     ];
     if (options.all) {
-        // Also delete data files
+        // Also delete data files. patterns.db / trajectories.db are pre-unified
+        // legacy paths kept here so `reset --all` still cleans them up on
+        // upgraded installs; the live writers all target memory.db now.
         filesToReset.push(path.join(aqeDir, 'memory.db'), path.join(aqeDir, 'patterns.db'), path.join(aqeDir, 'trajectories.db'), path.join(aqeDir, 'hnsw.index'));
     }
     for (const file of filesToReset) {

package/dist/coordination/consensus/providers/claude-provider.js

@@ -69,7 +69,7 @@ export class ClaudeModelProvider extends BaseModelProvider {
             throw new Error('Claude API key is required. Provide via config.apiKey or ANTHROPIC_API_KEY environment variable.');
         }
         this.apiKey = apiKey;
-        this.baseUrl = config.baseUrl || 'https://api.anthropic.com';
+        this.baseUrl = config.baseUrl || process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com';
         this.config = {
             apiKey,
             defaultModel: config.defaultModel || 'claude-sonnet-4-6',

package/dist/coordination/task-executor.js

@@ -297,9 +297,18 @@ export class DomainTaskExecutor {
             // Log outcome for debugging and metrics
             console.debug(`[TaskExecutor] Outcome recorded: task=${task.id}, tier=${tier}, ` +
                 `model=${getModelForTier(tier)}, success=${success}, duration=${durationMs}ms`);
-            // ADR-023: Record routing outcome for learning feedback loop
+            // ADR-023: Record routing outcome for learning feedback loop.
+            // qualityScore uses the 6-dim outcome formula (matches the post-task
+            // hook UPDATE path) instead of a binary success?0.8:0.2.
             if (this.qualityFeedbackLoop) {
                 const targetDomains = task.targetDomains || [];
+                const successScore = success ? 1 : 0;
+                const durationTier = durationMs < 100 ? 1.0 :
+                    durationMs < 500 ? 0.8 :
+                        durationMs < 2000 ? 0.6 :
+                            durationMs < 5000 ? 0.4 :
+                                durationMs < 10000 ? 0.2 : 0.1;
+                const qualityScore = 0.25 * successScore + 0.325 + 0.10 * durationTier;
                 await this.qualityFeedbackLoop.recordRoutingOutcome({
                     taskId: task.id,
                     taskDescription: task.type,
@@ -307,7 +316,7 @@ export class DomainTaskExecutor {
                     usedAgent: String(tier),
                     followedRecommendation: true,
                     success,
-                    qualityScore: success ? 0.8 : 0.2,
+                    qualityScore,
                     durationMs,
                     timestamp: new Date(),
                     error: success ? undefined : 'Task execution failed',

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/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/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)
  */