agentic-qe 3.13.11 → 3.14.0

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

@@ -46,6 +46,8 @@ export interface PatternStoreConfig {
     namespace: string;
     /** Dimension of embedding vectors */
     embeddingDimension: number;
+    /** Runtime-provided provenance override (primarily for injected embedders/tests). */
+    embeddingSpaceId?: string;
     /** HNSW configuration */
     hnsw: {
         M: number;
@@ -124,6 +126,8 @@ export interface PatternSearchOptions {
     context?: Partial<QEPatternContext>;
     /** Include vector similarity search */
     useVectorSearch?: boolean;
+    /** Provenance of a pre-computed query vector. Required for semantic ranking. */
+    embeddingSpaceId?: string;
     /**
      * Composable metadata filter expression (Task 1.2: ruvector-filter).
      * Applied post-search to refine results by domain, severity,
@@ -212,6 +216,7 @@ export declare class PatternStore implements IPatternStore {
     private typeIndex;
     private tierIndex;
     private hnswIndex;
+    private hnswSpaceId;
     private hnswAvailable;
     private hnswInitPromise;
     private hdcCache;

package/dist/learning/pattern-store.js

@@ -6,6 +6,8 @@
  * O(log n) approximate nearest neighbor search.
  */
 import { v4 as uuidv4 } from 'uuid';
+import { existsSync } from 'node:fs';
+import { join as joinPath } from 'node:path';
 // Issue #516: lightweight, sqlite-free project-root resolver (static import so it
 // resolves under the test runner; avoids pulling unified-memory's sqlite graph).
 import { findProjectRoot } from '../kernel/project-root.js';
@@ -28,6 +30,7 @@ import { createVectorDeltaTracker, } from '../integrations/ruvector/vector-delta
 import { createHopfieldMemory } from '../integrations/ruvector/hopfield-memory.js';
 import { createHyperbolicPatternIndex, } from './hyperbolic-pattern-index.js';
 import { PatternNullStore } from './pattern-null-store.js';
+import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 // ============================================================================
 // R1: HDC Fingerprint Singleton (lazy-initialized)
 // ============================================================================
@@ -120,6 +123,7 @@ export class PatternStore {
     // HNSW index for vector search (lazy loaded - ADR-048)
     // Using dynamic import type since HNSWIndex is lazily loaded
     hnswIndex = null;
+    hnswSpaceId = null;
     hnswAvailable = false;
     hnswInitPromise = null;
     // R1: HDC fingerprint cache (pattern ID -> fingerprint vector)
@@ -206,6 +210,11 @@ export class PatternStore {
     async ensureHNSW() {
         // Already initialized
         if (this.hnswIndex !== null) {
+            const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId ?? null;
+            if (this.hnswSpaceId !== activeSpaceId) {
+                console.warn('[PatternStore] VECTOR_SPACE_MISMATCH: active embedder changed; semantic index disabled');
+                return null;
+            }
             return this.hnswIndex;
         }
         // Already marked as unavailable
@@ -234,6 +243,10 @@ export class PatternStore {
      */
     async initializeHNSWInternal() {
         try {
+            this.hnswSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId ?? null;
+            if (!this.hnswSpaceId) {
+                throw new Error('VECTOR_SPACE_UNVERIFIED: cannot initialize HNSW without runtime provenance');
+            }
             // ADR-071: Use unified HNSW via bridge when flag is enabled
             const unifiedFlags = getRuVectorFeatureFlags();
             if (unifiedFlags.useUnifiedHnsw) {
@@ -302,10 +315,11 @@ export class PatternStore {
             const maxBootstrap = this.config.hnsw.maxElements;
             let loaded = 0;
             let skipped = 0;
-            for (const { patternId, embedding } of embeddings) {
+            const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId;
+            for (const { patternId, embedding, spaceId } of embeddings) {
                 if (loaded >= maxBootstrap)
                     break;
-                if (!embedding || embedding.length !== this.config.embeddingDimension) {
+                if (!activeSpaceId || spaceId !== activeSpaceId || !embedding || embedding.length !== this.config.embeddingDimension) {
                     skipped++;
                     continue;
                 }
@@ -429,6 +443,10 @@ export class PatternStore {
         if (pattern.confidence < this.config.minConfidence) {
             return err(new Error(`Pattern confidence ${pattern.confidence} below threshold ${this.config.minConfidence}`));
         }
+        const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId;
+        if (pattern.embedding && !activeSpaceId) {
+            return err(new Error('VECTOR_SPACE_UNVERIFIED: refusing to persist or index an embedding without runtime provenance'));
+        }
         // Check domain limit
         const domainCount = this.domainIndex.get(pattern.qeDomain)?.size || 0;
         if (domainCount >= this.config.maxPatternsPerDomain) {
@@ -442,7 +460,7 @@ export class PatternStore {
         // Persist to SQLite (pattern + embedding atomically)
         if (this.sqliteStore) {
             try {
-                const actualId = this.sqliteStore.storePattern(pattern, pattern.embedding);
+                const actualId = this.sqliteStore.storePattern(pattern, pattern.embedding, activeSpaceId);
                 // #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
@@ -703,6 +721,10 @@ export class PatternStore {
             }
             // Vector search if query is embedding and HNSW available (lazy-load)
             if (Array.isArray(query) && options.useVectorSearch !== false) {
+                const activeSpaceId = getActiveEmbeddingSpaceIdentity()?.spaceId ?? this.config.embeddingSpaceId;
+                if (!activeSpaceId || options.embeddingSpaceId !== activeSpaceId) {
+                    throw new Error('VECTOR_SPACE_UNVERIFIED: pre-computed query vectors require the active embeddingSpaceId');
+                }
                 const hnsw = await this.ensureHNSW();
                 if (hnsw) {
                     const hnswResults = await hnsw.search(query, limit * 2);
@@ -1410,8 +1432,6 @@ export function createPatternStore(memory, config) {
             // Only use RVF if the data directory exists (created by kernel init).
             // Issue #516: anchor to the project root so a subfolder cwd reads/writes
             // the project's own .agentic-qe/ rather than a cwd-relative stray store.
-            const { existsSync } = require('fs');
-            const { join: joinPath } = require('path');
             const projectRoot = process.env.AQE_PROJECT_ROOT ?? findProjectRoot();
             const rvfDir = joinPath(projectRoot, '.agentic-qe');
             const rvfPath = joinPath(rvfDir, 'patterns.rvf');
@@ -1431,7 +1451,12 @@ export function createPatternStore(memory, config) {
                     const shared = getSharedRvfAdapter(rvfDir, mergedConfig.embeddingDimension);
                     if (shared) {
                         useSharedAdapter = true;
-                        const store = new RvfPatternStore(() => shared, { rvfPath, base: mergedConfig, skipCloseOnDispose: true });
+                        const store = new RvfPatternStore(() => shared, {
+                            rvfPath,
+                            base: mergedConfig,
+                            skipCloseOnDispose: true,
+                            embeddingSpaceId: mergedConfig.embeddingSpaceId,
+                        });
                         console.log('[PatternStore] Using RVF-backed store (ADR-066)');
                         return store;
                     }
@@ -1487,7 +1512,11 @@ export function createPatternStore(memory, config) {
                             }
                             throw createErr;
                         }
-                    }, { rvfPath, base: mergedConfig });
+                    }, {
+                        rvfPath,
+                        base: mergedConfig,
+                        embeddingSpaceId: mergedConfig.embeddingSpaceId,
+                    });
                     console.log('[PatternStore] Using RVF-backed store (ADR-066)');
                     return store;
                 }

package/dist/learning/qe-flywheel/coupled-anchor.d.ts

@@ -21,6 +21,7 @@
  * (the LLM step is the metered part — bind it deliberately).
  */
 import type { Database as DatabaseType } from 'better-sqlite3';
+import { type EmbeddingSpaceIdentity } from '../embedding-space.js';
 import type { RetrievalPolicy } from './policy.js';
 import type { PolicyScorer } from './generation.js';
 /** A pattern retrieved as a few-shot example for test generation. */
@@ -73,6 +74,13 @@ export interface SemanticRetrieverOptions {
     db: DatabaseType;
     /** Embed a query into the pattern-embedding space. Default: all-MiniLM-L6-v2. */
     embed?: (text: string) => Promise<number[]>;
+    /** Storage-side embedding path used by the executable round-trip canary. */
+    writeEmbed?: (text: string) => Promise<number[]>;
+    /** Runtime identities for injected embedders. Defaults to the active AQE embedder. */
+    embeddingSpace?: EmbeddingSpaceIdentity;
+    writeEmbeddingSpace?: EmbeddingSpaceIdentity;
+    /** Explicit non-semantic fallback used when provenance cannot be verified. */
+    fallback?: RetrieveFn;
     topK?: number;
 }
 /**

package/dist/learning/qe-flywheel/coupled-anchor.js

@@ -20,7 +20,8 @@
  * a real policy-weighted DB retriever + an LLM test generator in production
  * (the LLM step is the metered part — bind it deliberately).
  */
-import { computeRealEmbedding } from '../real-embeddings.js';
+import { computeRealEmbedding, getActiveEmbeddingSpaceIdentity } from '../real-embeddings.js';
+import { EmbeddingSpaceError, inspectEmbeddingSpaceRows, verifyEmbeddingRoundTrip, } from '../embedding-space.js';
 import { evaluateOracle } from '../../validation/oracle-eval.js';
 import { loadAnchorSet, anchorMean as meanOf } from '../../validation/anchor-set.js';
 import { createCorpusScorer } from './corpus-scorer.js';
@@ -124,20 +125,62 @@ function cosine(a, b) {
 export function createSemanticRetriever(opts) {
     const embed = opts.embed ?? ((t) => computeRealEmbedding(t));
     const topK = opts.topK ?? 3;
+    const hasSpaceId = opts.db.prepare("PRAGMA table_info('qe_pattern_embeddings')").all()
+        .some((column) => column.name === 'space_id');
     const rows = opts.db.prepare(`SELECT p.id AS id, p.name AS name, COALESCE(p.description,'') AS body,
-            e.embedding AS embedding, e.dimension AS dimension
+            e.embedding AS embedding, e.dimension AS dimension, ${hasSpaceId ? 'e.space_id' : 'NULL'} AS space_id
        FROM qe_patterns p JOIN qe_pattern_embeddings e ON e.pattern_id = p.id
       WHERE p.deprecated_at IS NULL`).all();
     const toks = (s) => new Set(s.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
     const docs = rows.map((r) => ({
-        id: r.id, name: r.name, body: r.body,
+        id: r.id, name: r.name, body: r.body, spaceId: r.space_id,
         vec: new Float32Array(r.embedding.buffer, r.embedding.byteOffset, r.dimension),
         nameToks: toks(r.name), bodyToks: toks(r.body),
     }));
     const queryCache = new Map();
+    let compatibilityCheck = null;
     return async (query, policy) => {
         if (docs.length === 0)
             return [];
+        try {
+            if (!opts.writeEmbed) {
+                throw new EmbeddingSpaceError('VECTOR_SPACE_UNVERIFIED', 'an independent storage-side embedder is required for the write/read canary');
+            }
+            if (!compatibilityCheck) {
+                compatibilityCheck = verifyEmbeddingRoundTrip(opts.writeEmbed, embed);
+            }
+            try {
+                await compatibilityCheck;
+            }
+            catch (error) {
+                compatibilityCheck = null;
+                throw error;
+            }
+            const activeIdentity = opts.embeddingSpace ?? getActiveEmbeddingSpaceIdentity();
+            const writeIdentity = opts.writeEmbeddingSpace ?? activeIdentity;
+            if (!activeIdentity || !writeIdentity) {
+                throw new EmbeddingSpaceError('VECTOR_SPACE_UNVERIFIED', 'runtime embedding-space identity is unavailable');
+            }
+            if (writeIdentity.spaceId !== activeIdentity.spaceId) {
+                throw new EmbeddingSpaceError('VECTOR_SPACE_MISMATCH', `write space ${writeIdentity.spaceId} != query space ${activeIdentity.spaceId}`);
+            }
+            const invalidDimensions = docs.filter((doc) => doc.vec.length !== activeIdentity.dimensions);
+            if (invalidDimensions.length > 0) {
+                throw new EmbeddingSpaceError('VECTOR_SPACE_MISMATCH', `${invalidDimensions.length} stored vectors have dimensions incompatible with ${activeIdentity.dimensions}`);
+            }
+            const diagnostics = inspectEmbeddingSpaceRows(docs.map((doc) => ({ spaceId: doc.spaceId })), activeIdentity.spaceId);
+            if (diagnostics.unverifiedVectors > 0) {
+                throw new EmbeddingSpaceError('VECTOR_SPACE_UNVERIFIED', `${diagnostics.unverifiedVectors} stored vectors have no provenance`);
+            }
+            if (diagnostics.status === 'vector_space_mismatch') {
+                throw new EmbeddingSpaceError('VECTOR_SPACE_MISMATCH', `stored spaces [${diagnostics.storedSpaceIds.join(', ')}] do not match ${activeIdentity.spaceId}`);
+            }
+        }
+        catch (error) {
+            if (opts.fallback)
+                return opts.fallback(query, policy);
+            throw error;
+        }
         let qv = queryCache.get(query);
         if (!qv) {
             qv = new Float32Array(await embed(query));

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

@@ -22,6 +22,7 @@ import { getGuidance, getCombinedGuidance, generateGuidanceContext, checkAntiPat
 import { createPatternStore, } from './pattern-store.js';
 import { createSQLitePatternStore, } from './sqlite-persistence.js';
 import { getWitnessChain } from '../audit/witness-chain.js';
+import { getActiveEmbeddingSpaceIdentity } from './real-embeddings.js';
 // Import extracted modules
 import { DEFAULT_QE_REASONING_BANK_CONFIG } from './qe-reasoning-bank-types.js';
 import { PRETRAINED_PATTERNS } from './pretrained-patterns.js';
@@ -323,6 +324,9 @@ export class QEReasoningBank {
         return this.patternStore.search(searchQuery, {
             ...options,
             useVectorSearch,
+            embeddingSpaceId: typeof query === 'string'
+                ? getActiveEmbeddingSpaceIdentity()?.spaceId
+                : options?.embeddingSpaceId,
         });
     }
     /**

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