agentic-qe 3.11.4 → 3.11.5

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

@@ -474,6 +474,24 @@ export class DreamEngine {
         this.ensureInitialized();
         return this.graph.loadFromPatterns(patterns);
     }
+    /**
+     * Load real ADR-110 pattern-null (failure) data as 'error' concept nodes
+     * (A8-EXT) — public wrapper for direct/test use; `ensureConceptsLoaded()`
+     * calls this automatically from the real qe_pattern_nulls table.
+     */
+    async loadFailuresAsConcepts(failures) {
+        this.ensureInitialized();
+        return this.graph.loadFailuresAsErrors(failures);
+    }
+    /**
+     * Load real qe_pattern_usage success data as 'outcome' concept nodes
+     * (A8-EXT) — public wrapper for direct/test use; `ensureConceptsLoaded()`
+     * calls this automatically from the real qe_pattern_usage table.
+     */
+    async loadSuccessesAsConcepts(successes) {
+        this.ensureInitialized();
+        return this.graph.loadSuccessesAsOutcomes(successes);
+    }
     /**
      * Ensure sufficient concepts are loaded for dreaming.
      * If the concept graph has fewer nodes than minConceptsRequired,
@@ -483,17 +501,70 @@ export class DreamEngine {
      */
     async ensureConceptsLoaded() {
         this.ensureInitialized();
+        // A8-EXT follow-up fix: this refresh must NOT be gated behind the
+        // "do we have enough concepts to dream at all" check below — on any
+        // project that's run more than a handful of dream cycles,
+        // `existing.length` permanently exceeds `minConceptsRequired`, so the
+        // gate would make this whole block unreachable in real, automatic
+        // operation forever (only reachable via the direct
+        // loadFailuresAsConcepts()/loadSuccessesAsConcepts() test/manual
+        // wrappers). Runs on every call instead: loadFailuresAsErrors() /
+        // loadSuccessesAsOutcomes() are idempotent (synthetic
+        // `error:<id>`/`outcome:<id>` keys), and each query is a single
+        // indexed LIMIT-100 read, so refreshing every dream cycle is cheap.
+        try {
+            const failureRows = this.db.prepare(`SELECT n.id as id, n.pattern_id as sourcePatternId, p.qe_domain as domain, n.failure_mode as failureMode
+         FROM qe_pattern_nulls n
+         JOIN qe_patterns p ON p.id = n.pattern_id
+         ORDER BY n.updated_at DESC
+         LIMIT 100`).all();
+            if (failureRows.length > 0) {
+                await this.graph.loadFailuresAsErrors(failureRows);
+            }
+            const successRows = this.db.prepare(`SELECT u.id as id, u.pattern_id as sourcePatternId, p.qe_domain as domain,
+                ('Pattern "' || p.name || '" applied successfully') as description
+         FROM qe_pattern_usage u
+         JOIN qe_patterns p ON p.id = u.pattern_id
+         WHERE u.success = 1
+         ORDER BY u.created_at DESC
+         LIMIT 100`).all();
+            if (successRows.length > 0) {
+                await this.graph.loadSuccessesAsOutcomes(successRows);
+            }
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                dreamLogger.debug('Error/outcome concept loading skipped', { error: toErrorMessage(error) });
+            }
+        }
         const existing = await this.graph.getActiveNodes(0);
         if (existing.length >= this.config.minConceptsRequired) {
             return 0;
         }
-        // Load patterns from qe_patterns table in the shared unified DB
-        const rows = this.db.prepare(`SELECT id, name, description, qe_domain as domain, pattern_type as patternType,
-              confidence, success_rate as successRate
-       FROM qe_patterns
-       WHERE confidence >= 0.3
-       ORDER BY quality_score DESC
-       LIMIT 200`).all();
+        // Load patterns from qe_patterns table in the shared unified DB.
+        // A8-EXT: the top-160-by-quality pool alone starves detectOptimizations —
+        // quality_score already weights success_rate at 0.5, so the best-quality
+        // patterns are, by construction, rarely the "room for improvement"
+        // candidates that detector looks for. Union in a genuine low-performer
+        // sample (bottom-40 by success_rate among confidence>=0.3 patterns) so
+        // real optimization candidates actually reach the detector.
+        const rows = this.db.prepare(`SELECT * FROM (
+         SELECT id, name, description, qe_domain as domain, pattern_type as patternType,
+                confidence, success_rate as successRate
+         FROM qe_patterns
+         WHERE confidence >= 0.3
+         ORDER BY quality_score DESC
+         LIMIT 160
+       )
+       UNION
+       SELECT * FROM (
+         SELECT id, name, description, qe_domain as domain, pattern_type as patternType,
+                confidence, success_rate as successRate
+         FROM qe_patterns
+         WHERE confidence >= 0.3 AND success_rate < 0.7
+         ORDER BY usage_count DESC
+         LIMIT 40
+       )`).all();
         if (rows.length === 0) {
             return 0;
         }
@@ -526,9 +597,59 @@ export class DreamEngine {
                     error: 'Insight already applied',
                 };
             }
-            // Generate a pattern ID
-            const patternId = `dream-pattern-${uuidv4()}`;
-            // Mark insight as applied
+            // Create a REAL pattern in QEReasoningBank — this used to mint a fake
+            // `dream-pattern-<uuid>` that never resolved to any qe_patterns row.
+            // Single implementation shared with the MCP `apply` action (dream.ts)
+            // and the scheduler's autoApplyInsights, both of which call this method
+            // directly — no duplicate pattern-creation logic to drift out of sync.
+            const { getSharedMemoryBackend } = await import('../../mcp/tools/base.js');
+            const { createQEReasoningBank } = await import('../qe-reasoning-bank.js');
+            const memoryBackend = await getSharedMemoryBackend();
+            const reasoningBank = createQEReasoningBank(memoryBackend);
+            await reasoningBank.initialize();
+            // Wire RVF dual-writer (optional, best-effort — matches the prior
+            // MCP-only implementation's parity with other pattern-creation paths).
+            try {
+                const { getSharedRvfDualWriter } = await import('../../integrations/ruvector/shared-rvf-dual-writer.js');
+                const dualWriter = await getSharedRvfDualWriter();
+                if (dualWriter)
+                    reasoningBank.setRvfDualWriter(dualWriter);
+            }
+            catch (e) {
+                if (process.env.DEBUG)
+                    dreamLogger.debug('RVF wiring skipped', { error: toErrorMessage(e) });
+            }
+            let sourceConcepts = [];
+            try {
+                sourceConcepts = safeJsonParse(insightRow.source_concepts);
+            }
+            catch {
+                // Malformed source_concepts shouldn't block pattern creation.
+            }
+            const patternResult = await reasoningBank.storePattern({
+                patternType: mapInsightTypeToPatternType(insightRow.insight_type),
+                name: `Dream Insight: ${insightRow.insight_type}`,
+                description: `${insightRow.description} (confidence: ${insightRow.confidence_score.toFixed(2)})`,
+                template: {
+                    type: 'workflow',
+                    content: insightRow.suggested_action || insightRow.description,
+                    variables: [],
+                },
+                context: {
+                    tags: ['dream-generated', insightRow.insight_type, ...sourceConcepts.slice(0, 3)],
+                    complexity: 'medium',
+                },
+            });
+            if (!patternResult.success) {
+                // Do NOT mark applied — leave it retryable rather than silently
+                // swallowing a real pattern-creation failure behind a fake success.
+                return {
+                    success: false,
+                    error: `Failed to create pattern: ${patternResult.error?.message ?? 'unknown error'}`,
+                };
+            }
+            const patternId = patternResult.value.id;
+            // Mark insight as applied — pattern_id now points at the REAL row.
             const stmt = this.db.prepare(`
         UPDATE dream_insights
         SET applied = 1, pattern_id = ?
@@ -725,6 +846,21 @@ export class DreamEngine {
         };
     }
 }
+/**
+ * Map a dream insight type to the closest QEPatternType. Shared by
+ * DreamEngine.applyInsight — the single implementation used by both the
+ * MCP `apply` action and the scheduler's auto-apply path.
+ */
+function mapInsightTypeToPatternType(insightType) {
+    const mapping = {
+        'cross-domain': 'coverage-strategy',
+        'novel-path': 'test-template',
+        'cluster': 'refactor-safe',
+        'high-activation': 'assertion-pattern',
+        'bridge': 'mock-pattern',
+    };
+    return mapping[insightType] || 'test-template';
+}
 // ============================================================================
 // Factory Function
 // ============================================================================

package/dist/learning/dream/index.d.ts

@@ -48,7 +48,7 @@
  *
  * @module learning/dream
  */
-export type { ConceptType, EdgeType, InsightType, DreamCycleStatus, ConceptNode, CreateConceptNodeInput, ConceptEdge, CreateEdgeInput, DreamCycle, DreamInsight, ConceptGraphStats, ConceptGraphConfig, PatternImportData, NeighborResult, DreamEngineConfig, DreamCycleResult, } from './types.js';
+export type { ConceptType, EdgeType, InsightType, DreamCycleStatus, ConceptNode, CreateConceptNodeInput, ConceptEdge, CreateEdgeInput, DreamCycle, DreamInsight, ConceptGraphStats, ConceptGraphConfig, PatternImportData, FailureImportData, SuccessImportData, NeighborResult, DreamEngineConfig, DreamCycleResult, } from './types.js';
 export { DEFAULT_CONCEPT_GRAPH_CONFIG } from './types.js';
 export { ConceptGraph, createConceptGraph } from './concept-graph.js';
 export { SpreadingActivation, type ActivationConfig, type ActivationResult, DEFAULT_ACTIVATION_CONFIG, MAX_ACTIVATION_HISTORY_ENTRIES, MAX_COACTIVATION_ENTRIES, HISTORY_TRIM_TARGET_RATIO, } from './spreading-activation.js';

package/dist/learning/dream/types.d.ts

@@ -227,6 +227,29 @@ export interface PatternImportData {
     confidence?: number;
     successRate?: number;
 }
+/**
+ * Real ADR-110 pattern-null (recorded failure) data for importing as
+ * 'error' concept nodes — A8-EXT.
+ */
+export interface FailureImportData {
+    /** qe_pattern_nulls.id — unique, used as the node's synthetic patternId key */
+    id: string;
+    /** The pattern that failed (NOT used to create an edge — that would trivially satisfy "hasResolution") */
+    sourcePatternId: string;
+    domain: string;
+    failureMode: string;
+}
+/**
+ * Real qe_pattern_usage (successful application) data for importing as
+ * 'outcome' concept nodes — A8-EXT.
+ */
+export interface SuccessImportData {
+    /** qe_pattern_usage.id — unique, used as the node's synthetic patternId key */
+    id: number;
+    sourcePatternId: string;
+    domain: string;
+    description: string;
+}
 /**
  * Neighbor result with node and edge
  */

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

@@ -175,7 +175,7 @@ export interface IPatternStore {
     /** Search for patterns */
     search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
     /** Update pattern after use */
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     /** Promote pattern from short-term to long-term */
     promote(id: string): Promise<Result<void>>;
     /** Delete a pattern */
@@ -315,7 +315,7 @@ export declare class PatternStore implements IPatternStore {
     /**
      * Record pattern usage and update stats
      */
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     /**
      * Promote pattern from short-term to long-term storage
      */

package/dist/learning/pattern-store.js

@@ -436,7 +436,18 @@ export class PatternStore {
         // Persist to SQLite (pattern + embedding atomically)
         if (this.sqliteStore) {
             try {
-                this.sqliteStore.storePattern(pattern, pattern.embedding);
+                const actualId = this.sqliteStore.storePattern(pattern, pattern.embedding);
+                // #447: ON CONFLICT(name, qe_domain, pattern_type) may preserve an
+                // existing row's id instead of the one we generated — realign the
+                // in-memory indices (and pattern.id itself) or every later
+                // recordUsage()/promote()/delete() call for this pattern throws
+                // "Pattern not found" against SQLite while silently succeeding
+                // in-memory, permanently desyncing usage stats from qe_pattern_usage.
+                if (actualId && actualId !== pattern.id) {
+                    this.unindexPattern(pattern);
+                    pattern.id = actualId;
+                    this.indexPattern(pattern);
+                }
             }
             catch (error) {
                 console.warn(`[PatternStore] SQLite persist failed for ${pattern.id}:`, toErrorMessage(error));
@@ -987,7 +998,7 @@ export class PatternStore {
     /**
      * Record pattern usage and update stats
      */
-    async recordUsage(id, success) {
+    async recordUsage(id, success, metrics, feedback) {
         const pattern = await this.get(id);
         if (!pattern) {
             return err(new Error(`Pattern not found: ${id}`));
@@ -1016,7 +1027,7 @@ export class PatternStore {
         // Persist usage to SQLite
         if (this.sqliteStore) {
             try {
-                this.sqliteStore.recordUsage(id, success);
+                this.sqliteStore.recordUsage(id, success, metrics, feedback);
             }
             catch (error) {
                 console.warn(`[PatternStore] SQLite recordUsage failed for ${id}:`, toErrorMessage(error));

package/dist/learning/qe-reasoning-bank.js

@@ -343,16 +343,12 @@ export class QEReasoningBank {
         if (!this.config.enableLearning) {
             return ok(undefined);
         }
-        const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success);
-        // Persist usage to SQLite (updates qe_patterns row AND inserts qe_pattern_usage)
-        try {
-            const store = this.getSqliteStore();
-            store.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
-        }
-        catch (persistError) {
-            // Non-critical — don't fail if persistence fails
-            logger.warn('SQLite pattern usage persist failed', { error: toErrorMessage(persistError) });
-        }
+        // Single writer (#486 Gap B): patternStore.recordUsage() persists to SQLite
+        // itself (updates qe_patterns row AND inserts qe_pattern_usage) when a
+        // SQLitePatternStore is wired via setSqliteStore(). A second explicit
+        // SQLite write here previously double-counted every outcome — two
+        // qe_pattern_usage rows and a +2 usage_count for one recordOutcome() call.
+        const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
         if (result.success) {
             this.stats.learningOutcomes++;
             if (outcome.success) {
@@ -608,9 +604,18 @@ export class QEReasoningBank {
         // DB fallback (#454): in-memory `this.stats` is reset on every process
         // start, but every hook invocation spawns a fresh node. Without a DB
         // fallback, `aqe hooks stats` always reports zeros even when historical
-        // routing_outcomes / qe_pattern_usage rows exist. We use the in-memory
-        // counters when they're non-zero (live, current-process data), otherwise
-        // fall back to aggregated DB totals.
+        // routing_outcomes / qe_pattern_usage rows exist.
+        //
+        // routing_outcomes / qe_pattern_usage are written synchronously on every
+        // recordOutcome()/routeTask() call, so the DB aggregate is always a
+        // superset of (>=) the in-memory counters for this process. Previously
+        // this only consulted the DB when the in-memory counter was exactly
+        // zero, which made reported totals regress the moment in-memory ticked
+        // past zero mid-session — a cold-start call would correctly report the
+        // historical DB total, then the very next call after one recordOutcome()
+        // would drop to reporting just "1" instead of "historical total + 1".
+        // Taking the max keeps the number monotonic while still tolerating a
+        // failed/unavailable DB aggregate (falls back to in-memory).
         let routingRequests = this.stats.routingRequests;
         let avgRoutingConfidence = this.stats.routingRequests > 0
             ? this.stats.totalRoutingConfidence / this.stats.routingRequests
@@ -619,27 +624,25 @@ export class QEReasoningBank {
         let patternSuccessRate = this.stats.learningOutcomes > 0
             ? this.stats.successfulOutcomes / this.stats.learningOutcomes
             : 0;
-        if (routingRequests === 0 || learningOutcomes === 0) {
-            try {
-                const agg = this.getSqliteStore().getAggregateOutcomeStats();
-                if (routingRequests === 0 && agg.routingRequests > 0) {
-                    routingRequests = agg.routingRequests;
-                    avgRoutingConfidence = agg.avgRoutingConfidence;
-                }
-                if (learningOutcomes === 0 && agg.learningOutcomes > 0) {
-                    learningOutcomes = agg.learningOutcomes;
-                    // Prefer per-usage success rate (closer to recordOutcome semantics);
-                    // fall back to qe_patterns.success_rate aggregate when no usage rows.
-                    patternSuccessRate =
-                        agg.learningOutcomes > 0
-                            ? agg.successfulOutcomes / agg.learningOutcomes
-                            : agg.avgPatternSuccessRate;
-                }
+        try {
+            const agg = this.getSqliteStore().getAggregateOutcomeStats();
+            if (agg.routingRequests > routingRequests) {
+                routingRequests = agg.routingRequests;
+                avgRoutingConfidence = agg.avgRoutingConfidence;
             }
-            catch {
-                // best-effort — never let stats reporting crash the host
+            if (agg.learningOutcomes > learningOutcomes) {
+                learningOutcomes = agg.learningOutcomes;
+                // Prefer per-usage success rate (closer to recordOutcome semantics);
+                // fall back to qe_patterns.success_rate aggregate when no usage rows.
+                patternSuccessRate =
+                    agg.learningOutcomes > 0
+                        ? agg.successfulOutcomes / agg.learningOutcomes
+                        : agg.avgPatternSuccessRate;
             }
         }
+        catch {
+            // best-effort — never let stats reporting crash the host
+        }
         return {
             totalPatterns: patternStoreStats.totalPatterns,
             byDomain,

package/dist/learning/routing-topology-gate.d.ts

@@ -20,8 +20,18 @@
  *    permanently dampened in the exact deployment case ADR-095 was meant
  *    to help.
  *
- * Treat empty/uninitialized graph as "no signal" (full ε rate). Only
- * consult `isCritical()` when the graph has actual vertices.
+ *    A16 correction (2026-07-06): `graph.isEmpty()` alone doesn't catch
+ *    this — `QueenMinCutBridge` always seeds ~14 `domain:*` scaffold
+ *    vertices + workflow edges on init, so `isEmpty()` is false as soon as
+ *    Queen starts, even with zero real agents ever spawned. The mincut
+ *    over those scaffold-only edges (one-directional, `defect-intelligence`
+ *    a pure sink) computes to exactly 0.0 — still degenerate, still
+ *    "critical" by the threshold check. Check for real `agent:*` vertices
+ *    specifically (same fix `QueenMinCutBridge.isEmptyTopology()` already
+ *    applies internally), not raw vertex count.
+ *
+ * Treat a graph with no real agent vertices as "no signal" (full ε rate).
+ * Only consult `isCritical()` once at least one agent has actually spawned.
  */
 /**
  * Returns true ONLY when:

package/dist/learning/routing-topology-gate.js

@@ -20,8 +20,18 @@
  *    permanently dampened in the exact deployment case ADR-095 was meant
  *    to help.
  *
- * Treat empty/uninitialized graph as "no signal" (full ε rate). Only
- * consult `isCritical()` when the graph has actual vertices.
+ *    A16 correction (2026-07-06): `graph.isEmpty()` alone doesn't catch
+ *    this — `QueenMinCutBridge` always seeds ~14 `domain:*` scaffold
+ *    vertices + workflow edges on init, so `isEmpty()` is false as soon as
+ *    Queen starts, even with zero real agents ever spawned. The mincut
+ *    over those scaffold-only edges (one-directional, `defect-intelligence`
+ *    a pure sink) computes to exactly 0.0 — still degenerate, still
+ *    "critical" by the threshold check. Check for real `agent:*` vertices
+ *    specifically (same fix `QueenMinCutBridge.isEmptyTopology()` already
+ *    applies internally), not raw vertex count.
+ *
+ * Treat a graph with no real agent vertices as "no signal" (full ε rate).
+ * Only consult `isCritical()` once at least one agent has actually spawned.
  */
 import { getSharedMinCutGraph, getSharedMinCutMonitor, isSharedMinCutGraphInitialized, isSharedMinCutMonitorInitialized, } from '../coordination/mincut/shared-singleton.js';
 /**
@@ -44,7 +54,9 @@ export function resolveTopologyCriticalFromSharedMincut() {
         if (!isSharedMinCutGraphInitialized())
             return false;
         const graph = getSharedMinCutGraph();
-        if (graph.isEmpty())
+        // Domain-coordinator scaffold vertices/edges are always present once
+        // Queen initializes; they don't count as "the graph has real signal".
+        if (graph.getVerticesByType('agent').length === 0)
             return false;
         return getSharedMinCutMonitor().isCritical();
     }

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

@@ -63,7 +63,7 @@ export declare class RvfPatternStore implements IPatternStore {
     create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
     get(id: string): Promise<QEPattern | null>;
     search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     promote(id: string): Promise<Result<void>>;
     delete(id: string): Promise<Result<void>>;
     getStats(): Promise<PatternStoreStats>;

package/dist/learning/rvf-pattern-store.js

@@ -372,12 +372,12 @@ export class RvfPatternStore {
     // --------------------------------------------------------------------------
     // IPatternStore — Mutation operations
     // --------------------------------------------------------------------------
-    async recordUsage(id, success) {
+    async recordUsage(id, success, metrics, feedback) {
         if (!this.sqliteStore) {
             return err(new Error('No SQLite store attached'));
         }
         try {
-            this.sqliteStore.recordUsage(id, success);
+            this.sqliteStore.recordUsage(id, success, metrics, feedback);
             return ok(undefined);
         }
         catch (error) {
@@ -419,18 +419,31 @@ export class RvfPatternStore {
     }
     async getStats() {
         const rvfStatus = this.adapter?.status();
-        // Get pattern count from RVF if available, otherwise fall back to SQLite
-        let totalPatterns = rvfStatus?.totalVectors ?? 0;
-        if (totalPatterns === 0 && this.sqliteStore) {
+        // qe_patterns (SQLite) is the source of truth for pattern count and
+        // domain/tier breakdown — the RVF vector index only covers patterns
+        // that have actually been embedded, and is reported separately via
+        // hnswStats.vectorCount. Previously this used RVF's totalVectors as the
+        // headline count, which silently hid any pattern stored without a
+        // matching embedding (#553).
+        let totalPatterns = 0;
+        let byDomain = {};
+        let byTier = { shortTerm: 0, longTerm: 0 };
+        if (this.sqliteStore) {
             try {
-                totalPatterns = this.sqliteStore.getStats().totalPatterns;
+                const sqliteStats = this.sqliteStore.getStats();
+                totalPatterns = sqliteStats.totalPatterns;
+                byDomain = sqliteStats.byDomain;
+                byTier = {
+                    shortTerm: sqliteStats.byTier['short-term'] ?? 0,
+                    longTerm: sqliteStats.byTier['long-term'] ?? 0,
+                };
             }
             catch { /* best effort */ }
         }
         return {
             totalPatterns,
-            byTier: { shortTerm: 0, longTerm: 0 },
-            byDomain: {},
+            byTier,
+            byDomain,
             byType: {},
             avgConfidence: 0,
             avgQualityScore: 0,

package/dist/learning/sqlite-persistence.js

@@ -391,24 +391,27 @@ export class SQLitePatternStore {
         if (!insertPattern || !insertEmbedding) {
             throw new Error('Prepared statements not ready');
         }
+        let actualId = id;
         // Use transaction for atomicity
         const transaction = this.db.transaction(() => {
             insertPattern.run(id, pattern.patternType, pattern.qeDomain, pattern.domain, pattern.name, pattern.description || '', pattern.confidence, pattern.tier || 'short-term', JSON.stringify(pattern.template), JSON.stringify(pattern.context));
+            // #447: ON CONFLICT(name, qe_domain, pattern_type) preserves the
+            // existing row's id instead of `id`. Resolve the actual id BEFORE
+            // inserting the embedding — qe_pattern_embeddings.pattern_id has a
+            // FOREIGN KEY on qe_patterns(id), so inserting under the discarded
+            // `id` (no such row) throws "FOREIGN KEY constraint failed".
+            const actualRow = this.db
+                .prepare('SELECT id FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?')
+                .get(pattern.name, pattern.qeDomain ?? '', pattern.patternType ?? '');
+            actualId = actualRow ? actualRow.id : id;
             if (embedding) {
                 // Store embedding as BLOB (Float32Array)
                 const buffer = Buffer.from(new Float32Array(embedding).buffer);
-                insertEmbedding.run(id, buffer, embedding.length, 'all-MiniLM-L6-v2');
+                insertEmbedding.run(actualId, buffer, embedding.length, 'all-MiniLM-L6-v2');
             }
         });
         transaction();
-        // #447: ON CONFLICT(name, qe_domain, pattern_type) preserves the existing
-        // row's id, so the new `id` we just tried to insert may not be what's
-        // actually stored. SELECT the actual id back so callers (rvf-pattern-store,
-        // qe-hooks) can stay consistent with HNSW and downstream usage tables.
-        const actualRow = this.db
-            .prepare('SELECT id FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?')
-            .get(pattern.name, pattern.qeDomain ?? '', pattern.patternType ?? '');
-        return actualRow ? actualRow.id : id;
+        return actualId;
     }
     /**
      * Get a pattern by ID