agentic-qe 3.13.12 → 3.14.0

package/dist/learning/real-embeddings.d.ts

@@ -7,6 +7,7 @@
  */
 export { cosineSimilarity } from '../shared/utils/vector-math.js';
 import { type EndpointIdentity } from './embedder-endpoint-client.js';
+import { type EmbeddingSpaceIdentity } from './embedding-space.js';
 /**
  * Embedding model configuration
  */
@@ -83,4 +84,6 @@ export declare function isUsingEndpoint(): boolean;
  * ADR-097: Returns the endpoint identity fingerprint, or null when not using an endpoint.
  */
 export declare function getEndpointIdentity(): EndpointIdentity | null;
+/** Runtime-backed identity of the initialized embedding space. */
+export declare function getActiveEmbeddingSpaceIdentity(): EmbeddingSpaceIdentity | null;
 //# sourceMappingURL=real-embeddings.d.ts.map

package/dist/learning/real-embeddings.js

@@ -10,6 +10,7 @@ export { cosineSimilarity } from '../shared/utils/vector-math.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { EmbedderEndpointClient, redactEndpoint, } from './embedder-endpoint-client.js';
 import { loadEmbedderIdentity, resetEmbedderIdentityStore, saveEmbedderIdentity, } from './embedder-identity-store.js';
+import { EMBEDDING_SPACE_CANARY, deriveEmbeddingSpaceIdentity, fingerprintEmbeddingRuntime, } from './embedding-space.js';
 // Lazy-loaded transformer pipeline
 let pipeline = null;
 let embeddingModel = null;
@@ -22,6 +23,7 @@ let failureReason = '';
  */
 let endpointClient = null;
 let endpointIdentity = null;
+let activeEmbeddingSpaceIdentity = null;
 export const DEFAULT_EMBEDDING_CONFIG = {
     modelName: 'Xenova/all-MiniLM-L6-v2',
     quantized: true,
@@ -100,6 +102,16 @@ async function initializeModel(config = {}) {
                 });
                 // Probe + identity fingerprint. Fails loud on dim mismatch.
                 endpointIdentity = await endpointClient.probe();
+                activeEmbeddingSpaceIdentity = deriveEmbeddingSpaceIdentity({
+                    provider: 'openai-compatible-endpoint',
+                    model: fullConfig.modelName,
+                    dimensions: endpointIdentity.dim,
+                    pooling: 'mean',
+                    normalized: true,
+                    preprocessingVersion: 'aqe-text-v1',
+                    implementation: endpointIdentity.endpoint,
+                    runtimeFingerprint: endpointIdentity.fingerprint,
+                });
                 console.log(`[RealEmbeddings] Endpoint identity: dim=${endpointIdentity.dim} fingerprint=${endpointIdentity.fingerprint}`);
                 // Cross-run drift detection: compare against the last-known identity
                 // for this endpoint (memory.db kv_store, namespace _system). If the
@@ -136,9 +148,11 @@ async function initializeModel(config = {}) {
             }
             catch {
                 throw new Error('In-process embeddings require the optional package "@huggingface/transformers", ' +
-                    'which is not installed. Either run `npm install @huggingface/transformers`, or ' +
-                    'configure an embedding endpoint (EmbeddingConfig.endpoint / AQE_EMBEDDER_ENDPOINT) ' +
-                    'so no local model is loaded.');
+                    'which is not installed. Configure an embedding endpoint ' +
+                    '(EmbeddingConfig.endpoint / AQE_EMBEDDER_ENDPOINT) so no local model is loaded. ' +
+                    'Installing @huggingface/transformers@4.2.0 is an explicit security opt-in: ' +
+                    'its compatible dependency chain currently has unresolved HIGH advisories ' +
+                    'GHSA-xcpc-8h2w-3j85 and GHSA-f88m-g3jw-g9cj.');
             }
             pipeline = transformers.pipeline;
             console.log(`[RealEmbeddings] Loading model: ${fullConfig.modelName}`);
@@ -147,6 +161,24 @@ async function initializeModel(config = {}) {
             embeddingModel = await pipeline('feature-extraction', fullConfig.modelName, {
                 quantized: fullConfig.quantized,
             });
+            const initializedModel = embeddingModel;
+            if (!initializedModel)
+                throw new Error('Transformer pipeline returned no embedding model');
+            const canary = await initializedModel(EMBEDDING_SPACE_CANARY, {
+                pooling: 'mean',
+                normalize: true,
+            });
+            const canaryVector = Array.from(canary.data);
+            activeEmbeddingSpaceIdentity = deriveEmbeddingSpaceIdentity({
+                provider: 'huggingface-transformers',
+                model: fullConfig.modelName,
+                dimensions: canaryVector.length,
+                pooling: 'mean',
+                normalized: true,
+                preprocessingVersion: 'aqe-text-v1',
+                implementation: `transformers:${fullConfig.quantized ? 'quantized' : 'full'}`,
+                runtimeFingerprint: fingerprintEmbeddingRuntime(canaryVector),
+            });
             const loadTime = performance.now() - startTime;
             console.log(`[RealEmbeddings] Model loaded in ${loadTime.toFixed(0)}ms`);
         }
@@ -356,6 +388,7 @@ export function resetInitialization() {
     }
     endpointClient = null;
     endpointIdentity = null;
+    activeEmbeddingSpaceIdentity = null;
     // Drop the identity-store's cached DB connection so tests that flip cwd or
     // AQE_MEMORY_PATH between runs don't write into a stale handle.
     resetEmbedderIdentityStore();
@@ -373,4 +406,8 @@ export function isUsingEndpoint() {
 export function getEndpointIdentity() {
     return endpointIdentity;
 }
+/** Runtime-backed identity of the initialized embedding space. */
+export function getActiveEmbeddingSpaceIdentity() {
+    return activeEmbeddingSpaceIdentity;
+}
 //# sourceMappingURL=real-embeddings.js.map

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

@@ -19,8 +19,9 @@ import { v4 as uuidv4 } from 'uuid';
 import { LoggerFactory } from '../logging/index.js';
 import { toError, toErrorMessage } from '../shared/error-utils.js';
 import { maybeEnhanceRoutingWithPatterns } from './pattern-routing-guidance.js';
+import { EMBEDDING_SPACE_CANARY } from './embedding-space.js';
 const logger = LoggerFactory.create('RealQEReasoningBank');
-import { computeRealEmbedding, isTransformerAvailable, getEmbeddingDimension, clearEmbeddingCache, } from './real-embeddings.js';
+import { computeRealEmbedding, isTransformerAvailable, getEmbeddingDimension, clearEmbeddingCache, getActiveEmbeddingSpaceIdentity, } from './real-embeddings.js';
 import { createSQLitePatternStore, } from './sqlite-persistence.js';
 import { detectQEDomain, detectQEDomains, mapQEDomainToAQE, QE_DOMAIN_LIST, shouldPromotePattern, } from './qe-patterns.js';
 import { getGuidance, getCombinedGuidance, generateGuidanceContext, checkAntiPatterns, } from './qe-guidance.js';
@@ -164,6 +165,8 @@ export class RealQEReasoningBank {
         // Initialize SQLite persistence
         await this.sqliteStore.initialize();
         logger.info('SQLite persistence initialized');
+        // Establish executable provenance before any persisted vectors enter ANN.
+        await computeRealEmbedding(EMBEDDING_SPACE_CANARY, this.qeConfig.embeddings);
         // Initialize HNSW index
         await this.initializeHNSW();
         logger.info('HNSW index initialized');
@@ -228,9 +231,10 @@ export class RealQEReasoningBank {
         const expectedDim = getEmbeddingDimension();
         let loaded = 0;
         let skipped = 0;
-        for (const { patternId, embedding } of embeddings) {
+        const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId;
+        for (const { patternId, embedding, spaceId } of embeddings) {
             // Skip invalid or corrupted embeddings
-            if (!embedding || !Array.isArray(embedding) || embedding.length !== expectedDim) {
+            if (!activeSpaceId || spaceId !== activeSpaceId || !embedding || !Array.isArray(embedding) || embedding.length !== expectedDim) {
                 skipped++;
                 continue;
             }

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

@@ -33,6 +33,8 @@ export interface MigrationOptions {
     dimension?: number;
     /** Log progress every N patterns (default: 1000) */
     progressInterval?: number;
+    /** Runtime embedding space that the destination RVF index is bound to. */
+    embeddingSpaceId?: string;
 }
 /**
  * Migrate pattern embeddings from SQLite to an RVF file.

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

@@ -12,6 +12,7 @@
  *
  * @module learning/rvf-pattern-migration
  */
+import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 // ============================================================================
 // Migration Function
 // ============================================================================
@@ -52,10 +53,11 @@ export function migratePatterns(sqliteStore, rvfAdapter, options = {}) {
     console.log(`[RVF Migration] Found ${allEmbeddings.length} embeddings to migrate (dim=${dimension})`);
     // Process in batches
     let batch = [];
+    const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? options.embeddingSpaceId;
     for (let i = 0; i < allEmbeddings.length; i++) {
-        const { patternId, embedding } = allEmbeddings[i];
-        // Skip if dimension doesn't match
-        if (embedding.length !== dimension) {
+        const { patternId, embedding, spaceId } = allEmbeddings[i];
+        // Never mix unknown or incompatible spaces in an ANN file.
+        if (!activeSpaceId || spaceId !== activeSpaceId || embedding.length !== dimension) {
             result.totalSkipped++;
             continue;
         }

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

@@ -22,6 +22,8 @@ export interface RvfPatternStoreConfig {
     base: PatternStoreConfig;
     /** When true, dispose() will not close the adapter (shared singleton) */
     skipCloseOnDispose?: boolean;
+    /** Runtime provenance for an injected embedder. */
+    embeddingSpaceId?: string;
 }
 /**
  * Pattern store backed by @ruvector/rvf-node for persistent HNSW.
@@ -34,6 +36,7 @@ export declare class RvfPatternStore implements IPatternStore {
     private readonly config;
     private readonly rvfPath;
     private readonly skipCloseOnDispose;
+    private readonly embeddingSpaceId?;
     private adapter;
     private sqliteStore;
     private initialized;

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

@@ -16,6 +16,8 @@ import { ok, err } from '../shared/types/index.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { calculateQualityScore, validateQEPattern, mapQEDomainToAQE, PROMOTION_THRESHOLD, } from './qe-patterns.js';
 import { DEFAULT_PATTERN_STORE_CONFIG } from './pattern-store.js';
+import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
+import { verifyOrCreateEmbeddingSpaceManifest } from './embedding-space.js';
 // ============================================================================
 // RVF Pattern Store Implementation
 // ============================================================================
@@ -30,6 +32,7 @@ export class RvfPatternStore {
     config;
     rvfPath;
     skipCloseOnDispose;
+    embeddingSpaceId;
     adapter = null;
     sqliteStore = null;
     initialized = false;
@@ -41,6 +44,7 @@ export class RvfPatternStore {
         this.config = config?.base ?? DEFAULT_PATTERN_STORE_CONFIG;
         this.rvfPath = config?.rvfPath ?? '.agentic-qe/patterns.rvf';
         this.skipCloseOnDispose = config?.skipCloseOnDispose ?? false;
+        this.embeddingSpaceId = config?.embeddingSpaceId;
     }
     /**
      * Attach SQLite persistence for metadata (pattern fields, FTS5).
@@ -69,6 +73,8 @@ export class RvfPatternStore {
         }
         try {
             this.adapter = this.createAdapter(this.rvfPath, this.config.embeddingDimension);
+            const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.embeddingSpaceId ?? null;
+            verifyOrCreateEmbeddingSpaceManifest(this.rvfPath, activeSpaceId, this.adapter.status()?.totalVectors ?? 0);
             this.initialized = true;
             console.log(`[RvfPatternStore] Initialized: ${this.rvfPath} (dim=${this.config.embeddingDimension})`);
         }
@@ -77,6 +83,10 @@ export class RvfPatternStore {
             // so they need to know RVF is not working. Log a clear error, set
             // adapter to null, and mark nativeAvailable=false in stats.
             this.rvfInitError = toErrorMessage(error);
+            try {
+                this.adapter?.close();
+            }
+            catch { /* best effort */ }
             console.error(`[RvfPatternStore] ERROR: RVF native init failed — vector search is DISABLED. ` +
                 `Cause: ${this.rvfInitError}. ` +
                 `Fix: install @ruvector/rvf-node native bindings, or set useRVFPatternStore=false to use SQLite HNSW.`);
@@ -162,6 +172,10 @@ export class RvfPatternStore {
         if (pattern.confidence < this.config.minConfidence) {
             return err(new Error(`Pattern confidence ${pattern.confidence} below threshold ${this.config.minConfidence}`));
         }
+        const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.embeddingSpaceId;
+        if (pattern.embedding && !activeSpaceId) {
+            return err(new Error('VECTOR_SPACE_UNVERIFIED: refusing to persist or index an embedding without runtime provenance'));
+        }
         // Persist metadata to SQLite. #447: capture the returned id — ON CONFLICT
         // on (name, qe_domain, pattern_type) preserves the existing row's id, so
         // we must align pattern.id with what's actually stored before ingesting
@@ -169,7 +183,7 @@ export class RvfPatternStore {
         // with "Pattern not found" and qe_pattern_usage stays empty).
         if (this.sqliteStore) {
             try {
-                const actualId = this.sqliteStore.storePattern(pattern, pattern.embedding);
+                const actualId = this.sqliteStore.storePattern(pattern, pattern.embedding, activeSpaceId);
                 if (actualId && actualId !== pattern.id) {
                     // QEPattern.id is `readonly` for callers, but inside the store
                     // we own the lifecycle and must align it with the persisted row
@@ -245,6 +259,12 @@ export class RvfPatternStore {
         const startTime = performance.now();
         const limit = options.limit ?? 10;
         const results = [];
+        if (Array.isArray(query)) {
+            const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.embeddingSpaceId;
+            if (!activeSpaceId || options.embeddingSpaceId !== activeSpaceId) {
+                return err(new Error('VECTOR_SPACE_UNVERIFIED: pre-computed query vectors require the active embeddingSpaceId'));
+            }
+        }
         // Vector search via RVF native HNSW
         if (Array.isArray(query) && this.adapter) {
             try {

package/dist/learning/sqlite-persistence.d.ts

@@ -13,6 +13,7 @@
  */
 import { type Database as DatabaseType } from 'better-sqlite3';
 import type { QEPattern, QEDomain } from './qe-patterns.js';
+import { type EmbeddingSpaceDiagnostics } from './embedding-space.js';
 /**
  * SQLite persistence configuration
  */
@@ -71,11 +72,12 @@ export declare class SQLitePatternStore {
     /**
      * Prepare commonly used statements
      */
+    private ensureEmbeddingSpaceSchema;
     private prepareStatements;
     /**
      * Store a pattern
      */
-    storePattern(pattern: QEPattern, embedding?: number[]): string;
+    storePattern(pattern: QEPattern, embedding?: number[], embeddingSpaceId?: string): string;
     /**
      * Get a pattern by ID
      */
@@ -113,6 +115,7 @@ export declare class SQLitePatternStore {
     getAllEmbeddings(): Array<{
         patternId: string;
         embedding: number[];
+        spaceId: string | null;
     }>;
     /**
      * Get up to `limit` embeddings, most-recently-used first.
@@ -124,7 +127,9 @@ export declare class SQLitePatternStore {
     getRecentEmbeddings(limit: number): Array<{
         patternId: string;
         embedding: number[];
+        spaceId: string | null;
     }>;
+    getEmbeddingSpaceDiagnostics(activeSpaceId?: string | null): EmbeddingSpaceDiagnostics;
     /**
      * Record pattern usage.
      *
@@ -191,7 +196,7 @@ export declare class SQLitePatternStore {
     /**
      * Store embedding for an existing pattern
      */
-    storePatternEmbedding(patternId: string, embedding: number[]): void;
+    storePatternEmbedding(patternId: string, embedding: number[], embeddingSpaceId?: string): void;
     /**
      * Record pattern reuse for metrics tracking (Phase 5.4)
      *

package/dist/learning/sqlite-persistence.js

@@ -16,7 +16,8 @@ import { v4 as uuidv4 } from 'uuid';
 import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
-import { computeBatchEmbeddings, getEmbeddingDimension, isUsingEndpoint, } from './real-embeddings.js';
+import { computeBatchEmbeddings, getEmbeddingDimension, isUsingEndpoint, getActiveEmbeddingSpaceIdentity, } from './real-embeddings.js';
+import { EMBEDDING_SPACE_CANARY, inspectEmbeddingSpaceRows, } from './embedding-space.js';
 import { recordPatternUsage } from './pattern-usage-recorder.js';
 export const DEFAULT_SQLITE_CONFIG = {
     // LEGACY: Ignored when useUnified=true (the default). All data goes to memory.db
@@ -106,6 +107,8 @@ export class SQLitePatternStore {
             }
             // Run deduplication migration (one-time, idempotent)
             this.deduplicatePatterns();
+            // Legacy rows remain NULL/unverified; only new writes receive provenance.
+            this.ensureEmbeddingSpaceSchema();
             // Prepare statements
             this.prepareStatements();
             this.initialized = true;
@@ -143,11 +146,12 @@ export class SQLitePatternStore {
       );
 
       -- Pattern embeddings table (BLOB storage for vectors)
-      CREATE TABLE IF NOT EXISTS qe_pattern_embeddings (
+      CREATE TABLE IF NOT EXISTS qe_pattern_embeddings (
         pattern_id TEXT PRIMARY KEY,
         embedding BLOB NOT NULL,
         dimension INTEGER NOT NULL,
-        model TEXT DEFAULT 'all-MiniLM-L6-v2',
+        model TEXT DEFAULT 'all-MiniLM-L6-v2',
+        space_id TEXT,
         created_at TEXT DEFAULT (datetime('now')),
         FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
       );
@@ -298,6 +302,15 @@ export class SQLitePatternStore {
     /**
      * Prepare commonly used statements
      */
+    ensureEmbeddingSpaceSchema() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const columns = this.db.prepare("PRAGMA table_info('qe_pattern_embeddings')").all();
+        if (!columns.some((column) => column.name === 'space_id')) {
+            this.db.exec('ALTER TABLE qe_pattern_embeddings ADD COLUMN space_id TEXT');
+        }
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_qe_pattern_embeddings_space ON qe_pattern_embeddings(space_id)');
+    }
     prepareStatements() {
         if (!this.db)
             throw new Error('Database not initialized');
@@ -323,14 +336,14 @@ export class SQLitePatternStore {
         updated_at = datetime('now')
     `));
         this.prepared.set('insertEmbedding', this.db.prepare(`
-      INSERT OR REPLACE INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model)
-      VALUES (?, ?, ?, ?)
+      INSERT OR REPLACE INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, space_id)
+      VALUES (?, ?, ?, ?, ?)
     `));
         this.prepared.set('getPattern', this.db.prepare(`
       SELECT * FROM qe_patterns WHERE id = ?
     `));
         this.prepared.set('getPatternWithEmbedding', this.db.prepare(`
-      SELECT p.*, e.embedding, e.dimension
+      SELECT p.*, e.embedding, e.dimension, e.space_id
       FROM qe_patterns p
       LEFT JOIN qe_pattern_embeddings e ON p.id = e.pattern_id
       WHERE p.id = ?
@@ -360,13 +373,13 @@ export class SQLitePatternStore {
       SELECT * FROM qe_patterns WHERE qe_domain = ? ORDER BY quality_score DESC LIMIT ?
     `));
         this.prepared.set('getAllEmbeddings', this.db.prepare(`
-      SELECT pattern_id, embedding, dimension FROM qe_pattern_embeddings
+      SELECT pattern_id, embedding, dimension, space_id FROM qe_pattern_embeddings
     `));
         // Recent-first variant used by the RVF backfill path. Order by
         // qe_patterns.last_used_at (then created_at) so the bounded backfill keeps
         // the most actively-used patterns when the cap is hit.
         this.prepared.set('getRecentEmbeddings', this.db.prepare(`
-      SELECT e.pattern_id, e.embedding, e.dimension
+      SELECT e.pattern_id, e.embedding, e.dimension, e.space_id
         FROM qe_pattern_embeddings e
         LEFT JOIN qe_patterns p ON p.id = e.pattern_id
        ORDER BY COALESCE(p.last_used_at, p.created_at, e.created_at) DESC
@@ -382,7 +395,7 @@ export class SQLitePatternStore {
     /**
      * Store a pattern
      */
-    storePattern(pattern, embedding) {
+    storePattern(pattern, embedding, embeddingSpaceId) {
         if (!this.db)
             throw new Error('Database not initialized');
         const id = pattern.id || uuidv4();
@@ -405,9 +418,13 @@ export class SQLitePatternStore {
                 .get(pattern.name, pattern.qeDomain ?? '', pattern.patternType ?? '');
             actualId = actualRow ? actualRow.id : id;
             if (embedding) {
+                const spaceId = embeddingSpaceId ?? getActiveEmbeddingSpaceIdentity()?.spaceId;
+                if (!spaceId) {
+                    throw new Error('VECTOR_SPACE_UNVERIFIED: refusing to persist an embedding without runtime provenance');
+                }
                 // Store embedding as BLOB (Float32Array)
                 const buffer = Buffer.from(new Float32Array(embedding).buffer);
-                insertEmbedding.run(actualId, buffer, embedding.length, 'all-MiniLM-L6-v2');
+                insertEmbedding.run(actualId, buffer, embedding.length, 'all-MiniLM-L6-v2', spaceId);
             }
         });
         transaction();
@@ -529,6 +546,7 @@ export class SQLitePatternStore {
         return rows.map(row => ({
             patternId: row.pattern_id,
             embedding: Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimension)),
+            spaceId: row.space_id,
         }));
     }
     /**
@@ -549,8 +567,15 @@ export class SQLitePatternStore {
         return rows.map(row => ({
             patternId: row.pattern_id,
             embedding: Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimension)),
+            spaceId: row.space_id,
         }));
     }
+    getEmbeddingSpaceDiagnostics(activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? null) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const rows = this.db.prepare('SELECT space_id AS spaceId FROM qe_pattern_embeddings').all();
+        return inspectEmbeddingSpaceRows(rows, activeSpaceId);
+    }
     /**
      * Record pattern usage.
      *
@@ -788,7 +813,7 @@ export class SQLitePatternStore {
     /**
      * Store embedding for an existing pattern
      */
-    storePatternEmbedding(patternId, embedding) {
+    storePatternEmbedding(patternId, embedding, embeddingSpaceId) {
         if (!this.db)
             throw new Error('Database not initialized');
         const insertEmbedding = this.prepared.get('insertEmbedding');
@@ -797,7 +822,11 @@ export class SQLitePatternStore {
         }
         // Convert embedding to Buffer for storage
         const buffer = Buffer.from(new Float32Array(embedding).buffer);
-        insertEmbedding.run(patternId, buffer, embedding.length, 'all-MiniLM-L6-v2');
+        const spaceId = embeddingSpaceId ?? getActiveEmbeddingSpaceIdentity()?.spaceId;
+        if (!spaceId) {
+            throw new Error('VECTOR_SPACE_UNVERIFIED: refusing to persist an embedding without runtime provenance');
+        }
+        insertEmbedding.run(patternId, buffer, embedding.length, 'all-MiniLM-L6-v2', spaceId);
     }
     /**
      * Record pattern reuse for metrics tracking (Phase 5.4)
@@ -935,14 +964,22 @@ export class SQLitePatternStore {
         if (!this.db)
             throw new Error('Database not initialized');
         const dimension = getEmbeddingDimension(); // 384
-        // Find patterns without embeddings (skip bench patterns)
-        const patternsWithout = this.db.prepare(`
-      SELECT p.id, p.name, p.description, p.pattern_type, p.qe_domain
-      FROM qe_patterns p
-      WHERE p.id NOT IN (SELECT pattern_id FROM qe_pattern_embeddings)
-        AND p.id NOT LIKE 'bench-%'
-      ORDER BY p.quality_score DESC
-    `).all();
+        // Initialize the executable identity before choosing repair candidates.
+        // The canary is cached by the embedding layer and is never persisted.
+        await computeBatchEmbeddings([EMBEDDING_SPACE_CANARY]);
+        const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId;
+        if (!activeSpaceId) {
+            throw new Error('VECTOR_SPACE_UNVERIFIED: backfill embedder has no runtime provenance');
+        }
+        // Repair absent, legacy/unverified, and mismatched embeddings.
+        const patternsWithout = this.db.prepare(`
+      SELECT p.id, p.name, p.description, p.pattern_type, p.qe_domain
+      FROM qe_patterns p
+      LEFT JOIN qe_pattern_embeddings e ON e.pattern_id = p.id
+      WHERE (e.pattern_id IS NULL OR e.space_id IS NULL OR e.space_id <> ?)
+        AND p.id NOT LIKE 'bench-%'
+      ORDER BY p.quality_score DESC
+    `).all(activeSpaceId);
         const alreadyHad = this.db.prepare(`
       SELECT COUNT(*) as c FROM qe_pattern_embeddings
     `).get();
@@ -1012,7 +1049,7 @@ export class SQLitePatternStore {
                             continue;
                         }
                         const buffer = Buffer.from(new Float32Array(embedding).buffer);
-                        insertEmbedding.run(textsWithIds[j].id, buffer, dimension, embeddingTag);
+                        insertEmbedding.run(textsWithIds[j].id, buffer, dimension, embeddingTag, activeSpaceId);
                         processed++;
                     }
                     catch (e) {