agentic-qe 3.13.11 → 3.14.0

package/dist/integrations/ruvector/brain-rvf-exporter.js

@@ -110,6 +110,25 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
                 ? domainFilterForColumn(options.domains, config.domainColumn)
                 : [undefined, []];
             let rows = queryAll(db, config.tableName, where, params);
+            if (options.domains && options.domains.length > 0) {
+                const manifestIds = new Set((allTableData.learning_evidence_manifests ?? []).map(row => row.id));
+                const patternIds = new Set((allTableData.qe_patterns ?? []).map(row => row.id));
+                if (['learning_evidence_segments', 'learning_segment_edges', 'learning_evidence_admissions'].includes(config.tableName)) {
+                    rows = rows.filter(row => manifestIds.has(row.manifest_id));
+                }
+                else if (config.tableName === 'pattern_manifest_lineage') {
+                    rows = rows.filter(row => {
+                        const lineage = row;
+                        return manifestIds.has(lineage.manifest_id) && patternIds.has(lineage.pattern_id);
+                    });
+                }
+                else if (config.tableName === 'pattern_segment_lineage') {
+                    rows = rows.filter(row => {
+                        const lineage = row;
+                        return manifestIds.has(lineage.manifest_id) && patternIds.has(lineage.pattern_id);
+                    });
+                }
+            }
             if (config.tableName === 'qe_patterns') {
                 for (const p of rows) {
                     if (p.qe_domain)
@@ -128,50 +147,28 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
         let embeddingCount = 0;
         const embeddingEntries = [];
         if (tableExists(db, 'qe_pattern_embeddings')) {
-            const rows = db.prepare('SELECT pattern_id, embedding, dimension FROM qe_pattern_embeddings').all();
+            const hasSpaceId = db.prepare("PRAGMA table_info('qe_pattern_embeddings')").all()
+                .some((column) => column.name === 'space_id');
+            const rows = db.prepare(`SELECT pattern_id, embedding, dimension, ${hasSpaceId ? 'space_id' : 'NULL'} AS space_id
+           FROM qe_pattern_embeddings`).all();
             for (const row of rows) {
-                if (row.embedding && row.dimension === dimension) {
+                // Legacy vectors without executable provenance remain in the embedded
+                // SQLite kernel for re-embedding, but must never enter the portable ANN
+                // index where their space would be indistinguishable from query vectors.
+                if (row.embedding && row.dimension === dimension && row.space_id) {
                     embeddingEntries.push({
                         id: `pe:${row.pattern_id}`,
                         vector: new Float32Array(row.embedding.buffer, row.embedding.byteOffset, dimension),
-                        metadata: { tableName: 'qe_pattern_embeddings' },
-                    });
-                }
-            }
-        }
-        if (tableExists(db, 'captured_experiences')) {
-            const rows = db.prepare('SELECT id, embedding, embedding_dimension, domain, quality FROM captured_experiences WHERE embedding IS NOT NULL').all();
-            for (const row of rows) {
-                if (row.embedding_dimension === dimension) {
-                    embeddingEntries.push({
-                        id: `exp:${row.id}`,
-                        vector: new Float32Array(row.embedding.buffer, row.embedding.byteOffset, dimension),
-                        metadata: {
-                            tableName: 'captured_experiences',
-                            domain: row.domain,
-                            confidence: row.quality,
-                        },
-                    });
-                }
-            }
-        }
-        if (tableExists(db, 'sona_patterns')) {
-            const rows = db.prepare('SELECT id, state_embedding, domain, confidence FROM sona_patterns WHERE state_embedding IS NOT NULL').all();
-            for (const row of rows) {
-                const dim = row.state_embedding.byteLength / 4;
-                if (dim === dimension) {
-                    embeddingEntries.push({
-                        id: `sona:${row.id}`,
-                        vector: new Float32Array(row.state_embedding.buffer, row.state_embedding.byteOffset, dimension),
-                        metadata: {
-                            tableName: 'sona_patterns',
-                            domain: row.domain,
-                            confidence: row.confidence,
-                        },
+                        metadata: { tableName: 'qe_pattern_embeddings', spaceId: row.space_id },
                     });
                 }
             }
         }
+        // captured_experiences and sona_patterns are still included in the kernel
+        // below, but their schemas do not yet carry embedding-space provenance.
+        // Mixing them into this ANN index would violate #633 even when dimensions
+        // and model labels happen to match, so they are intentionally excluded
+        // until their own write paths persist a space_id.
         if (embeddingEntries.length > 0) {
             const result = rvf.ingest(embeddingEntries);
             embeddingCount = result.accepted;
@@ -210,6 +207,7 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
                 dreamInsightCount: (allTableData['dream_insights'] || []).length,
                 witnessChainLength: (allTableData['witness_chain'] || []).length,
                 totalRecords,
+                tableCounts: Object.fromEntries(TABLE_CONFIGS.map(({ tableName }) => [tableName, allTableData[tableName]?.length ?? 0])),
             },
             domains: brainData.domains,
             checksum,
@@ -235,6 +233,53 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
         // sidecar, so renaming any earlier would publish an incomplete store.
         rvf.close();
         closed = true;
+        // Issue #629: a stage-2 mirror must not be destroyed when SQLite has just
+        // been recreated from seed data. Compare every mirrored table in the fully
+        // materialized candidate with the still-published store immediately before
+        // promotion. Inspection is fail-closed when the RVF itself remains readable
+        // but its kernel cannot yield a complete table inventory. A genuinely
+        // unreadable/corrupt RVF remains replaceable to preserve #563 recovery.
+        if (existsSync(outPath) && !options.allowOverwriteRicher) {
+            let existing;
+            try {
+                existing = brainInfoFromRvf(outPath);
+            }
+            catch (error) {
+                if (hasReadableBrainKernel(outPath) || !isKnownUnusableRvfError(error)) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    throw new Error(`RVF_MIRROR_INSPECTION_AMBIGUOUS: the existing mirror is readable but its ` +
+                        `richness could not be established (${detail}). Preserve/import it before retrying, ` +
+                        `or repeat with --force-overwrite-richer after preserving a backup.`);
+                }
+            }
+            if (existing) {
+                const existingCounts = existing.stats.tableCounts;
+                const candidateCounts = manifest.stats.tableCounts;
+                const missing = TABLE_CONFIGS
+                    .map(({ tableName }) => tableName)
+                    .filter((tableName) => !existingCounts || !Number.isSafeInteger(existingCounts[tableName]));
+                if (missing.length > 0) {
+                    throw new Error(`RVF_MIRROR_INSPECTION_AMBIGUOUS: existing mirror lacks trustworthy counts for ` +
+                        `${missing.join(', ')}. Preserve/import it before retrying, or repeat with ` +
+                        `--force-overwrite-richer after preserving a backup.`);
+                }
+                const richer = TABLE_CONFIGS
+                    .map(({ tableName }) => ({
+                    tableName,
+                    existing: existingCounts[tableName],
+                    candidate: candidateCounts[tableName],
+                }))
+                    .filter(({ existing: existingCount, candidate }) => existingCount > candidate);
+                if (richer.length > 0) {
+                    const differences = richer
+                        .map(({ tableName, existing: existingCount, candidate }) => `${tableName} ${existingCount} -> ${candidate}`)
+                        .join(', ');
+                    throw new Error(`RVF_MIRROR_RICHER: refusing to replace richer mirrored tables: ${differences}. ` +
+                        `Restore/import the mirror first, or repeat with --force-overwrite-richer after ` +
+                        `preserving a backup.`);
+                }
+            }
+        }
         // Promote tmp → final. The store itself goes last: until it lands, the
         // previous store (if any) is still the one on disk, and a crash mid-promote
         // leaves the old store readable rather than a half-written new one.
@@ -263,6 +308,36 @@ export function exportBrainToRvf(db, options, sourceDbLabel = 'memory.db') {
         throw err;
     }
 }
+/**
+ * Distinguish a corrupt/unopenable store (#563, replaceable) from a readable
+ * store whose richness inspection failed (ambiguous, therefore protected).
+ */
+function hasReadableBrainKernel(rvfPath) {
+    let rvf;
+    try {
+        rvf = openRvfStoreReadonly(resolve(rvfPath));
+        const kernel = rvf.extractKernel();
+        return Boolean(kernel?.image);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            rvf?.close();
+        }
+        catch { /* best-effort probe cleanup */ }
+    }
+}
+/**
+ * Only known structural corruption is replaceable without an operator
+ * override. Permission, locking, I/O, and programmer errors are ambiguous and
+ * must fail closed instead of being mistaken for disposable corruption.
+ */
+function isKnownUnusableRvfError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /ManifestNotFound|InvalidMagic|ChecksumMismatch|CorruptStore/i.test(message);
+}
 /** Legacy field-to-table mapping for older RVF exports. */
 const LEGACY_FIELD_MAP = {
     patterns: 'qe_patterns',
@@ -359,7 +434,7 @@ export function importBrainFromRvf(db, rvfPath, options) {
                 for (const row of rows) {
                     let result;
                     if (config.dedupColumns && config.dedupColumns.length > 0) {
-                        result = mergeAppendOnlyRow(db, config.tableName, row, config.dedupColumns);
+                        result = mergeAppendOnlyRow(db, config.tableName, row, config.dedupColumns, config.preserveId);
                     }
                     else {
                         const idCol = PK_COLUMNS[config.tableName] || 'id';
@@ -418,6 +493,11 @@ export function brainInfoFromRvf(rvfPath) {
         const qValueCount = t ? (t['rl_q_values']?.length ?? 0) : (brainData.qValues?.length ?? 0);
         const dreamInsightCount = t ? (t['dream_insights']?.length ?? 0) : (brainData.dreamInsights?.length ?? 0);
         const witnessChainLength = t ? (t['witness_chain']?.length ?? 0) : (brainData.witnessChain?.length ?? 0);
+        const tableCounts = t && typeof t === 'object' && !Array.isArray(t)
+            ? Object.fromEntries(Object.entries(t)
+                .filter((entry) => Array.isArray(entry[1]))
+                .map(([tableName, rows]) => [tableName, rows.length]))
+            : undefined;
         return {
             version: '3.0',
             format: 'rvf',
@@ -429,6 +509,7 @@ export function brainInfoFromRvf(rvfPath) {
                 qValueCount,
                 dreamInsightCount,
                 witnessChainLength,
+                ...(tableCounts ? { tableCounts } : {}),
             },
             domains: brainData.domains ?? [],
             checksum: sha256(brainJson),

package/dist/integrations/ruvector/brain-search.d.ts

@@ -4,7 +4,7 @@
  * Offline, read-only filtered search over a JSONL brain export directory.
  * Useful for exploring what a snapshot contains without importing it.
  *
- * Defaults to searching qe_patterns but can target any of the 25 exported
+ * Defaults to searching qe_patterns but can target any of the 31 exported
  * tables via the `table` option. Supports filters by domain, pattern_type,
  * date range, and a substring query that matches `name` + `description`.
  *

package/dist/integrations/ruvector/brain-search.js

@@ -4,7 +4,7 @@
  * Offline, read-only filtered search over a JSONL brain export directory.
  * Useful for exploring what a snapshot contains without importing it.
  *
- * Defaults to searching qe_patterns but can target any of the 25 exported
+ * Defaults to searching qe_patterns but can target any of the 31 exported
  * tables via the `table` option. Supports filters by domain, pattern_type,
  * date range, and a substring query that matches `name` + `description`.
  *

package/dist/integrations/ruvector/brain-shared.d.ts

@@ -7,7 +7,7 @@
  * This module owns:
  *   - Row type interfaces (PatternRow, QValueRow, DreamInsightRow, WitnessRow)
  *   - Merge result type and merge strategy type
- *   - TABLE_CONFIGS: data-driven list of all 25 exportable tables
+ *   - TABLE_CONFIGS: data-driven list of all 31 exportable tables
  *   - All 4 legacy merge functions + generic mergeGenericRow / mergeAppendOnlyRow
  *   - All SQL insert/update helpers
  *   - Utility functions (sha256, tableExists, queryAll, domainFilter, countRows)
@@ -94,6 +94,8 @@ export interface TableExportConfig {
     readonly blobColumns?: readonly string[];
     /** For tables with AUTOINCREMENT PK, specify dedup columns. */
     readonly dedupColumns?: readonly string[];
+    /** Preserve an `id` column when a deduplicated table does not use AUTOINCREMENT. */
+    readonly preserveId?: boolean;
 }
 /** PK column for tables with non-standard PK names. Default is 'id'. */
 export declare const PK_COLUMNS: Record<string, string>;
@@ -138,7 +140,7 @@ export declare function mergeGenericRow(db: Database.Database, tableName: string
  * Merge for append-only tables (AUTOINCREMENT PK).
  * Deduplicates by checking composite columns; inserts if no match found.
  */
-export declare function mergeAppendOnlyRow(db: Database.Database, tableName: string, row: Record<string, unknown>, dedupColumns: readonly string[]): MergeResult;
+export declare function mergeAppendOnlyRow(db: Database.Database, tableName: string, row: Record<string, unknown>, dedupColumns: readonly string[], preserveId?: boolean): MergeResult;
 export declare function mergePattern(db: Database.Database, pattern: PatternRow, strategy: MergeStrategy): MergeResult;
 export declare function mergeQValue(db: Database.Database, qv: QValueRow, strategy: MergeStrategy): MergeResult;
 export declare function mergeDreamInsight(db: Database.Database, insight: DreamInsightRow, strategy: MergeStrategy): MergeResult;

package/dist/integrations/ruvector/brain-shared.js

@@ -7,7 +7,7 @@
  * This module owns:
  *   - Row type interfaces (PatternRow, QValueRow, DreamInsightRow, WitnessRow)
  *   - Merge result type and merge strategy type
- *   - TABLE_CONFIGS: data-driven list of all 25 exportable tables
+ *   - TABLE_CONFIGS: data-driven list of all 31 exportable tables
  *   - All 4 legacy merge functions + generic mergeGenericRow / mergeAppendOnlyRow
  *   - All SQL insert/update helpers
  *   - Utility functions (sha256, tableExists, queryAll, domainFilter, countRows)
@@ -40,7 +40,7 @@ export const TIMESTAMP_COLUMNS = {
     goap_actions: 'updated_at',
     concept_edges: 'updated_at',
 };
-// --- TABLE_CONFIGS: All 25 exportable tables in FK-aware import order ---
+// --- TABLE_CONFIGS: All 31 exportable tables in FK-aware import order ---
 export const TABLE_CONFIGS = [
     { tableName: 'qe_patterns', fileName: 'patterns.jsonl', domainColumn: 'qe_domain' },
     { tableName: 'rl_q_values', fileName: 'q-values.jsonl', domainColumn: 'domain' },
@@ -67,6 +67,12 @@ export const TABLE_CONFIGS = [
     { tableName: 'experience_applications', fileName: 'experience-applications.jsonl' },
     { tableName: 'execution_results', fileName: 'execution-results.jsonl' },
     { tableName: 'executed_steps', fileName: 'executed-steps.jsonl' },
+    { tableName: 'learning_evidence_manifests', fileName: 'learning-evidence-manifests.jsonl', domainColumn: 'task_family' },
+    { tableName: 'learning_evidence_segments', fileName: 'learning-evidence-segments.jsonl', dedupColumns: ['manifest_id', 'id'], preserveId: true },
+    { tableName: 'learning_segment_edges', fileName: 'learning-segment-edges.jsonl', dedupColumns: ['manifest_id', 'parent_segment_id', 'child_segment_id', 'edge_kind'], preserveId: true },
+    { tableName: 'learning_evidence_admissions', fileName: 'learning-evidence-admissions.jsonl' },
+    { tableName: 'pattern_manifest_lineage', fileName: 'pattern-manifest-lineage.jsonl', dedupColumns: ['pattern_id', 'manifest_id', 'use_kind'], preserveId: true },
+    { tableName: 'pattern_segment_lineage', fileName: 'pattern-segment-lineage.jsonl', dedupColumns: ['pattern_id', 'manifest_id', 'segment_id', 'use_kind'], preserveId: true },
 ];
 // --- Derived BLOB column map (from TABLE_CONFIGS) ---
 /** Maps table names to their BLOB columns. Derived from TABLE_CONFIGS for convenience. */
@@ -249,7 +255,7 @@ export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestam
  * Merge for append-only tables (AUTOINCREMENT PK).
  * Deduplicates by checking composite columns; inserts if no match found.
  */
-export function mergeAppendOnlyRow(db, tableName, row, dedupColumns) {
+export function mergeAppendOnlyRow(db, tableName, row, dedupColumns, preserveId = false) {
     const validated = validateTableName(tableName);
     if (!tableExists(db, validated)) {
         dynamicInsert(db, validated, row);
@@ -263,7 +269,8 @@ export function mergeAppendOnlyRow(db, tableName, row, dedupColumns) {
     }
     // Strip AUTOINCREMENT id column before insert
     const insertRow = { ...row };
-    delete insertRow.id;
+    if (!preserveId)
+        delete insertRow.id;
     dynamicInsert(db, validated, insertRow);
     return { imported: 1, skipped: 0, conflicts: 0 };
 }

package/dist/integrations/ruvector/brain-table-ddl.d.ts

@@ -1,7 +1,7 @@
 /**
  * Brain Table DDL Definitions
  *
- * Contains CREATE TABLE statements for all 25 brain-exportable tables.
+ * Contains CREATE TABLE statements for all 31 brain-exportable tables.
  * Separated from brain-shared.ts to keep each file under 500 lines.
  *
  * Tables are listed in FK-aware import order:
@@ -10,7 +10,7 @@
  */
 import Database from 'better-sqlite3';
 /**
- * Ensure all 25 brain-exportable tables exist in the target database.
+ * Ensure all 31 brain-exportable tables exist in the target database.
  * Creates tables in FK-aware order so parent tables come before children.
  */
 export declare function ensureAllBrainTables(db: Database.Database): void;

package/dist/integrations/ruvector/brain-table-ddl.js

@@ -1,13 +1,14 @@
 /**
  * Brain Table DDL Definitions
  *
- * Contains CREATE TABLE statements for all 25 brain-exportable tables.
+ * Contains CREATE TABLE statements for all 31 brain-exportable tables.
  * Separated from brain-shared.ts to keep each file under 500 lines.
  *
  * Tables are listed in FK-aware import order:
  *   1. Parent tables first (qe_patterns, dream_cycles, goap_goals, etc.)
  *   2. Child tables after their parents (trajectory_steps after qe_trajectories, etc.)
  */
+import { LEARNING_EVIDENCE_SCHEMA } from '../../migrations/20260830_add_learning_evidence_tables.js';
 /**
  * All DDL statements for brain-exportable tables, in FK-aware creation order.
  * Uses CREATE TABLE IF NOT EXISTS for idempotency.
@@ -53,11 +54,12 @@ const BRAIN_TABLE_DDL = [
     action_data TEXT, timestamp TEXT NOT NULL, actor TEXT NOT NULL,
     hash_algo TEXT DEFAULT 'sha256', signature TEXT, signer_key_id TEXT
   )`,
-    `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',
-    created_at TEXT DEFAULT (datetime('now')),
-    FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
+    `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',
+    space_id TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
   )`,
     // --- Tier 1: New tables ---
     `CREATE TABLE IF NOT EXISTS captured_experiences (
@@ -192,7 +194,7 @@ const BRAIN_TABLE_DDL = [
     final_world_state TEXT, error_message TEXT,
     created_at TEXT DEFAULT (datetime('now'))
   )`,
-    `CREATE TABLE IF NOT EXISTS executed_steps (
+    `CREATE TABLE IF NOT EXISTS executed_steps (
     id TEXT PRIMARY KEY, execution_id TEXT NOT NULL,
     plan_id TEXT NOT NULL, action_id TEXT NOT NULL,
     step_order INTEGER NOT NULL, status TEXT NOT NULL,
@@ -202,15 +204,22 @@ const BRAIN_TABLE_DDL = [
     error_message TEXT,
     FOREIGN KEY (execution_id) REFERENCES execution_results(id)
   )`,
+    LEARNING_EVIDENCE_SCHEMA,
 ];
 /**
- * Ensure all 25 brain-exportable tables exist in the target database.
+ * Ensure all 31 brain-exportable tables exist in the target database.
  * Creates tables in FK-aware order so parent tables come before children.
  */
 export function ensureAllBrainTables(db) {
     for (const ddl of BRAIN_TABLE_DDL) {
         db.exec(ddl);
     }
+    const embeddingColumns = db.prepare("PRAGMA table_info('qe_pattern_embeddings')")
+        .all();
+    if (!embeddingColumns.some((column) => column.name === 'space_id')) {
+        db.exec('ALTER TABLE qe_pattern_embeddings ADD COLUMN space_id TEXT');
+    }
+    db.exec('CREATE INDEX IF NOT EXISTS idx_qe_pattern_embeddings_space ON qe_pattern_embeddings(space_id)');
 }
 /** List of all table names in creation/import order. */
 export const ALL_BRAIN_TABLE_NAMES = [
@@ -222,5 +231,8 @@ export const ALL_BRAIN_TABLE_NAMES = [
     'qe_pattern_usage', 'pattern_evolution_events', 'pattern_relationships',
     'pattern_versions', 'vectors', 'experience_applications',
     'execution_results', 'executed_steps',
+    'learning_evidence_manifests', 'learning_evidence_segments',
+    'learning_segment_edges', 'learning_evidence_admissions',
+    'pattern_manifest_lineage', 'pattern_segment_lineage',
 ];
 //# sourceMappingURL=brain-table-ddl.js.map

package/dist/integrations/ruvector/cognitive-container.js

@@ -238,7 +238,7 @@ export class CognitiveContainer {
                     for (const row of processedRows) {
                         let result;
                         if (config.dedupColumns && config.dedupColumns.length > 0) {
-                            result = mergeAppendOnlyRow(db, config.tableName, row, config.dedupColumns);
+                            result = mergeAppendOnlyRow(db, config.tableName, row, config.dedupColumns, config.preserveId);
                         }
                         else {
                             const idCol = PK_COLUMNS[config.tableName] || 'id';

package/dist/integrations/ruvector/rvf-dual-writer.d.ts

@@ -56,6 +56,8 @@ export interface DualWriteConfig {
     mode: 'dual-write' | 'rvf-primary' | 'sqlite-only';
     /** Whether to verify witness chain on startup */
     verifyOnStartup?: boolean;
+    /** Runtime provenance for an injected embedding pipeline. */
+    embeddingSpaceId?: string;
 }
 export interface DualWriteResult {
     sqliteSuccess: boolean;
@@ -76,6 +78,7 @@ export declare class RvfDualWriter {
     private rvfStore;
     private rvfAvailable;
     constructor(db: unknown, config: DualWriteConfig);
+    private activeSpaceId;
     /**
      * Initialize the RVF store (create or open).
      *
@@ -143,6 +146,7 @@ export declare class RvfDualWriter {
         epoch: number;
     } | null;
     private shouldWriteRvf;
+    private hasCompatibleEmbeddingSpace;
     private writeSqliteEmbedding;
     private deleteSqliteEmbedding;
     private getSqliteEmbeddingCount;

package/dist/integrations/ruvector/rvf-dual-writer.js

@@ -10,6 +10,8 @@
  * intercepting pattern embedding writes/deletes/searches and routing them
  * to one or both backends depending on the configured mode.
  */
+import { getActiveEmbeddingSpaceIdentity } from '../../learning/real-embeddings.js';
+import { verifyOrCreateEmbeddingSpaceManifest } from '../../learning/embedding-space.js';
 /**
  * Wraps the real RvfNativeAdapter to conform to the simpler RvfStore interface.
  */
@@ -48,6 +50,10 @@ function tableExists(db, name) {
     const row = db.prepare("SELECT COUNT(*) as cnt FROM sqlite_master WHERE type='table' AND name=?").get(name);
     return (row?.cnt ?? 0) > 0;
 }
+function columnExists(db, table, column) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    return rows.some((row) => row.name === column);
+}
 // ============================================================================
 // RvfDualWriter
 // ============================================================================
@@ -62,6 +68,16 @@ export class RvfDualWriter {
             ...config,
             dimensions: config.dimensions ?? 384,
         };
+        if (tableExists(this.db, 'qe_pattern_embeddings') && !columnExists(this.db, 'qe_pattern_embeddings', '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)');
+        }
+    }
+    activeSpaceId() {
+        // An injected writer belongs to the embedder that constructed it.  A
+        // process-global identity may describe a different pipeline initialized by
+        // another subsystem, so it is only a fallback for legacy callers.
+        return this.config.embeddingSpaceId ?? getActiveEmbeddingSpaceIdentity()?.spaceId;
     }
     /**
      * Initialize the RVF store (create or open).
@@ -104,6 +120,7 @@ export class RvfDualWriter {
                 }
             }
             this.rvfStore = wrapNativeAdapter(nativeAdapter, this.config.dimensions);
+            verifyOrCreateEmbeddingSpaceManifest(this.config.rvfPath, this.activeSpaceId() ?? null, this.rvfStore.status().totalVectors);
             this.rvfAvailable = true;
         }
         catch (err) {
@@ -134,6 +151,10 @@ export class RvfDualWriter {
             sqliteSuccess: false,
             rvfSuccess: false,
         };
+        const hasSpaceContract = columnExists(this.db, 'qe_pattern_embeddings', 'space_id');
+        if (!hasSpaceContract || !this.activeSpaceId()) {
+            return { ...result, divergence: 'VECTOR_SPACE_UNVERIFIED' };
+        }
         // 1. Always write to SQLite qe_pattern_embeddings
         try {
             this.writeSqliteEmbedding(patternId, embedding);
@@ -198,6 +219,8 @@ export class RvfDualWriter {
      * falls back to SQLite on error. Otherwise uses SQLite.
      */
     search(query, k) {
+        if (!this.hasCompatibleEmbeddingSpace())
+            return [];
         if (this.config.mode === 'rvf-primary' && this.rvfAvailable && this.rvfStore) {
             try {
                 return this.rvfStore.search(query, k);
@@ -326,6 +349,19 @@ export class RvfDualWriter {
             this.rvfAvailable &&
             this.rvfStore !== null);
     }
+    hasCompatibleEmbeddingSpace() {
+        if (!columnExists(this.db, 'qe_pattern_embeddings', 'space_id'))
+            return false;
+        const activeSpaceId = this.activeSpaceId();
+        if (!activeSpaceId)
+            return false;
+        const row = this.db.prepare(`
+      SELECT COUNT(*) AS incompatible
+        FROM qe_pattern_embeddings
+       WHERE space_id IS NULL OR space_id <> ?
+    `).get(activeSpaceId);
+        return (row?.incompatible ?? 0) === 0;
+    }
     writeSqliteEmbedding(patternId, embedding) {
         const blob = Buffer.from(embedding instanceof Float32Array
             ? embedding.buffer
@@ -333,14 +369,22 @@ export class RvfDualWriter {
         const dimension = embedding.length;
         // Upsert into qe_pattern_embeddings
         if (tableExists(this.db, 'qe_pattern_embeddings')) {
-            this.db.prepare(`
-        INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, created_at)
-        VALUES (?, ?, ?, 'all-MiniLM-L6-v2', datetime('now'))
-        ON CONFLICT(pattern_id) DO UPDATE SET
-          embedding = excluded.embedding,
-          dimension = excluded.dimension,
-          created_at = datetime('now')
-      `).run(patternId, blob, dimension);
+            const spaceId = this.activeSpaceId();
+            if (columnExists(this.db, 'qe_pattern_embeddings', 'space_id')) {
+                if (!spaceId)
+                    throw new Error('VECTOR_SPACE_UNVERIFIED: dual writer has no runtime provenance');
+                this.db.prepare(`
+          INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, space_id, created_at)
+          VALUES (?, ?, ?, 'all-MiniLM-L6-v2', ?, datetime('now'))
+          ON CONFLICT(pattern_id) DO UPDATE SET
+            embedding = excluded.embedding,
+            dimension = excluded.dimension,
+            space_id = excluded.space_id,
+            created_at = datetime('now')
+        `).run(patternId, blob, dimension, spaceId);
+                return;
+            }
+            throw new Error('VECTOR_SPACE_UNVERIFIED: canonical space_id column is unavailable');
         }
     }
     deleteSqliteEmbedding(patternId) {
@@ -367,7 +411,11 @@ export class RvfDualWriter {
     searchSqlite(query, k) {
         if (!tableExists(this.db, 'qe_pattern_embeddings'))
             return [];
-        const rows = this.db.prepare('SELECT pattern_id, embedding, dimension FROM qe_pattern_embeddings').all();
+        const activeSpaceId = this.activeSpaceId();
+        const hasSpaceContract = columnExists(this.db, 'qe_pattern_embeddings', 'space_id');
+        if (!hasSpaceContract || !activeSpaceId)
+            return [];
+        const rows = this.db.prepare('SELECT pattern_id, embedding, dimension FROM qe_pattern_embeddings WHERE space_id = ?').all(activeSpaceId);
         const queryArr = query instanceof Float32Array ? Array.from(query) : query;
         const queryMag = Math.sqrt(queryArr.reduce((s, v) => s + v * v, 0));
         if (queryMag === 0)

package/dist/integrations/ruvector/rvf-store-integrity.js

@@ -30,7 +30,7 @@ const LOCK_MAGIC = 'FLVR';
 /** Byte offset of the owning pid within a lock record (u32 LE). */
 const LOCK_PID_OFFSET = 4;
 /** Sidecars that belong to a store and must be quarantined alongside it. */
-const STORE_SIDECAR_SUFFIXES = ['', '.idmap.json', '.manifest.json'];
+const STORE_SIDECAR_SUFFIXES = ['', '.idmap.json', '.manifest.json', '.space.json'];
 /** Read the first `n` bytes of a file, or null if unreadable/shorter. */
 function readHead(path, n) {
     let fd;