agentic-qe 3.13.12 → 3.14.1

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,8 @@ 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 { PatternMutationError } from './pattern-mutation-error.js';
 // Import extracted modules
 import { DEFAULT_QE_REASONING_BANK_CONFIG } from './qe-reasoning-bank-types.js';
 import { PRETRAINED_PATTERNS } from './pretrained-patterns.js';
@@ -280,16 +282,34 @@ export class QEReasoningBank {
             options = { ...options, embedding };
         }
         const result = await this.patternStore.create(options);
+        // A pending-index error still proves the authoritative SQLite mutation
+        // committed. Resolve that committed row for witness and replication side
+        // effects, while returning the original typed partial disposition.
+        let committedPattern = result.success ? result.value : null;
+        if (!result.success &&
+            result.error instanceof PatternMutationError &&
+            result.error.disposition === 'COMMITTED_PENDING_INDEX') {
+            try {
+                committedPattern = await this.patternStore.get(result.error.patternId);
+            }
+            catch (error) {
+                logger.warn('Committed pattern lookup failed', {
+                    patternId: result.error.patternId,
+                    error: toErrorMessage(error),
+                });
+            }
+        }
         // ADR-070: Record pattern creation in witness chain
-        if (result.success) {
-            getWitnessChain().then(wc => wc.append('PATTERN_CREATE', { patternId: result.value.id, domain: result.value.qeDomain, confidence: result.value.confidence, name: result.value.name }, 'reasoning-bank')).catch((e) => { logger.warn('Witness chain PATTERN_CREATE failed', { error: toErrorMessage(e) }); });
+        if (committedPattern) {
+            const sideEffectPattern = committedPattern;
+            getWitnessChain().then(wc => wc.append('PATTERN_CREATE', { patternId: sideEffectPattern.id, domain: sideEffectPattern.qeDomain, confidence: sideEffectPattern.confidence, name: sideEffectPattern.name }, 'reasoning-bank')).catch((e) => { logger.warn('Witness chain PATTERN_CREATE failed', { error: toErrorMessage(e) }); });
             // Phase 3: Best-effort RVF dual-write for vector replication
-            if (this.rvfDualWriter && result.value.embedding && result.value.embedding.length > 0) {
+            if (this.rvfDualWriter && sideEffectPattern.embedding && sideEffectPattern.embedding.length > 0) {
                 try {
-                    this.rvfDualWriter.writePattern(result.value.id, result.value.embedding);
+                    this.rvfDualWriter.writePattern(sideEffectPattern.id, sideEffectPattern.embedding);
                 }
                 catch (rvfErr) {
-                    logger.warn('RVF dual-write failed (non-fatal)', { patternId: result.value.id, error: toErrorMessage(rvfErr) });
+                    logger.warn('RVF dual-write failed (non-fatal)', { patternId: sideEffectPattern.id, error: toErrorMessage(rvfErr) });
                 }
             }
         }
@@ -323,6 +343,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,9 @@ 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';
+import { PatternMutationError } from './pattern-mutation-error.js';
 // ============================================================================
 // RVF Pattern Store Implementation
 // ============================================================================
@@ -30,6 +33,7 @@ export class RvfPatternStore {
     config;
     rvfPath;
     skipCloseOnDispose;
+    embeddingSpaceId;
     adapter = null;
     sqliteStore = null;
     initialized = false;
@@ -41,6 +45,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).
@@ -59,9 +64,11 @@ export class RvfPatternStore {
     async initialize() {
         if (this.initialized)
             return;
+        this.rvfInitError = null;
         // Database-free mode (#534): never create an on-disk patterns.rvf (+ .idmap/.lock).
-        // Run adapter-less — the store degrades to metadata-only (the same graceful
-        // path used when the RVF native binding is unavailable), writing nothing.
+        // Run adapter-less and write nothing. The factory normally selects the
+        // in-memory PatternStore in this mode; a directly constructed RVF store
+        // remains fail-closed unless an authoritative SQLite delegate is attached.
         if (process.env.AQE_MEMORY_BACKEND === 'memory') {
             this.adapter = null;
             this.initialized = true;
@@ -69,6 +76,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 +86,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 +175,18 @@ export class RvfPatternStore {
         if (pattern.confidence < this.config.minConfidence) {
             return err(new Error(`Pattern confidence ${pattern.confidence} below threshold ${this.config.minConfidence}`));
         }
+        // RVF is a derived persistent index. A write is observable only through its
+        // authoritative SQLite metadata row, regardless of the process-wide memory
+        // setting. The factory routes memory mode to PatternStore, so a directly
+        // constructed RVF store without SQLite must fail before vector ingestion.
+        if (!this.sqliteStore) {
+            return err(new PatternMutationError(pattern.id, 'FAILED', new Error('authoritative SQLite pattern store is unavailable')));
+        }
+        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'));
+        }
+        let authoritativeCommitted = false;
         // 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,28 +194,35 @@ 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
                     // before HNSW ingest (otherwise the index keys diverge from SQLite).
                     pattern.id = actualId;
                 }
+                authoritativeCommitted = true;
             }
             catch (error) {
-                console.warn(`[RvfPatternStore] SQLite persist failed for ${pattern.id}:`, toErrorMessage(error));
+                return err(new PatternMutationError(pattern.id, 'FAILED', error));
             }
         }
+        if (pattern.embedding && !this.adapter && this.rvfInitError) {
+            return err(new PatternMutationError(pattern.id, authoritativeCommitted ? 'COMMITTED_PENDING_INDEX' : 'FAILED', new Error(`RVF unavailable ${authoritativeCommitted ? 'after' : 'before'} authoritative pattern commit: ${this.rvfInitError}`)));
+        }
         // Ingest vector into RVF
         if (pattern.embedding && this.adapter) {
             try {
                 const vec = pattern.embedding instanceof Float32Array
                     ? pattern.embedding
                     : new Float32Array(pattern.embedding);
-                this.adapter.ingest([{ id: pattern.id, vector: vec }]);
+                const ingest = this.adapter.ingest([{ id: pattern.id, vector: vec }]);
+                if (ingest.accepted !== 1 || ingest.rejected !== 0) {
+                    throw new Error(`RVF rejected pattern vector (accepted=${ingest.accepted}, rejected=${ingest.rejected})`);
+                }
             }
             catch (error) {
-                console.warn(`[RvfPatternStore] RVF ingest failed for ${pattern.id}:`, toErrorMessage(error));
+                return err(new PatternMutationError(pattern.id, authoritativeCommitted ? 'COMMITTED_PENDING_INDEX' : 'FAILED', error));
             }
         }
         return ok(pattern.id);
@@ -245,6 +277,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)
      *