agentic-qe 3.9.18 → 3.9.19

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/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/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.