agentic-qe 3.14.2 → 3.14.4

package/dist/init/settings-merge.js

@@ -104,19 +104,44 @@ export function mergeHooksSmart(existingHooks, newAqeHooks) {
  * `AQE_LEARNING_ENABLED=false` keeps their choice. Non-AQE env vars are always
  * preserved. Returns a new object; inputs are not mutated.
  */
-export function mergeAqeEnv(existingEnv, aqeEnv) {
+export function mergeAqeEnv(existingEnv, aqeEnv, options = {}) {
     // AQE defaults first, then existing values win on any key collision.
-    return { ...aqeEnv, ...(existingEnv || {}) };
+    const merged = { ...aqeEnv, ...(existingEnv || {}) };
+    if (options.memoryBackend === 'memory') {
+        // An explicit --no-database re-init must replace stale AQE persistence
+        // settings, even if the previous init wrote them into this env block.
+        // Custom paths remain inert under the memory backend and are needed when
+        // switching back. Only discard AQE's generated database locations.
+        for (const key of ['AQE_MEMORY_PATH', 'AQE_V3_REASONING_BANK']) {
+            if (merged[key] === '.agentic-qe/memory.db')
+                delete merged[key];
+        }
+        merged.AQE_MEMORY_BACKEND = 'memory';
+        merged.AQE_LEARNING_ENABLED = 'false';
+        merged.AQE_WORKERS_ENABLED = 'false';
+    }
+    else if (existingEnv?.AQE_MEMORY_BACKEND === 'memory') {
+        // Undo the overrides written by memory-mode init. Ordinary user overrides
+        // still win when there is no memory-mode marker.
+        for (const key of ['AQE_MEMORY_BACKEND', 'AQE_LEARNING_ENABLED', 'AQE_WORKERS_ENABLED']) {
+            if (Object.prototype.hasOwnProperty.call(aqeEnv, key))
+                merged[key] = aqeEnv[key];
+            else
+                delete merged[key];
+        }
+    }
+    return merged;
 }
 /**
  * Generate the full set of AQE environment variables for settings.json.
  */
-export function generateAqeEnvVars(config) {
+export function generateAqeEnvVars(config, options = {}) {
     const domains = config.domains?.enabled || [];
+    const dbFree = options.memoryBackend === 'memory';
     return {
-        AQE_MEMORY_PATH: '.agentic-qe/memory.db',
+        ...(dbFree ? { AQE_MEMORY_BACKEND: 'memory', AQE_WORKERS_ENABLED: 'false' } : { AQE_MEMORY_PATH: '.agentic-qe/memory.db' }),
         AQE_MEMORY_ENABLED: 'true',
-        AQE_LEARNING_ENABLED: config.learning?.enabled ? 'true' : 'false',
+        AQE_LEARNING_ENABLED: dbFree ? 'false' : config.learning?.enabled ? 'true' : 'false',
         AQE_V3_MODE: 'true',
         AQE_V3_DDD_ENABLED: 'true',
         AQE_V3_DOMAINS: domains.join(','),
@@ -126,7 +151,7 @@ export function generateAqeEnvVars(config) {
         AQE_V3_HNSW_ENABLED: config.learning?.hnswConfig ? 'true' : 'false',
         AQE_V3_HOOKS_ENABLED: 'true',
         AQE_V3_AISP_ENABLED: 'true',
-        AQE_V3_REASONING_BANK: '.agentic-qe/memory.db',
+        ...(!dbFree ? { AQE_V3_REASONING_BANK: '.agentic-qe/memory.db' } : {}),
         AQE_V3_PATTERN_PROMOTION_THRESHOLD: String(config.learning?.promotionThreshold ?? 3),
         AQE_V3_SUCCESS_RATE_THRESHOLD: String(config.learning?.qualityThreshold ?? 0.7),
     };
@@ -206,14 +231,20 @@ export function applyV3Sections(settings, sections, options = {}) {
             settings[key] = deepMergeOwned(settings[key], value);
         }
     }
+    if (options.memoryBackend === 'memory') {
+        const learning = settings.v3Learning;
+        if (learning?.reasoningBank)
+            delete learning.reasoningBank.dbPath;
+    }
     return settings;
 }
 /**
  * Generate v3-specific settings sections for settings.json.
  * These sections enable the self-learning system, status line, and permissions.
  */
-export function generateV3SettingsSections(config, projectRoot) {
+export function generateV3SettingsSections(config, projectRoot, options = {}) {
     const domains = config.domains?.enabled || [];
+    const dbFree = options.memoryBackend === 'memory';
     return {
         aqe: {
             version: config.version ?? '3.0.0',
@@ -243,9 +274,9 @@ export function generateV3SettingsSections(config, projectRoot) {
             },
         },
         v3Learning: {
-            enabled: config.learning?.enabled ?? true,
+            enabled: dbFree ? false : config.learning?.enabled ?? true,
             reasoningBank: {
-                dbPath: '.agentic-qe/memory.db',
+                ...(!dbFree ? { dbPath: '.agentic-qe/memory.db' } : {}),
                 enableHNSW: !!config.learning?.hnswConfig,
             },
             patternPromotion: {

package/dist/integrations/agentic-flow/model-router/types.js

@@ -11,6 +11,7 @@
  *
  * @module integrations/agentic-flow/model-router/types
  */
+import { CLAUDE_TIER_MODELS, DEFAULT_OPUS_MODEL, DEFAULT_SONNET_MODEL, } from '../../../shared/llm/model-registry.js';
 /**
  * Metadata for all model tiers
  */
@@ -46,7 +47,7 @@ export const TIER_METADATA = {
         ],
         typicalLatencyMs: 500,
         relativeCost: 1,
-        exampleModels: ['claude-haiku-4-5-20251001', 'gpt-4o-mini', 'gemini-flash'],
+        exampleModels: [CLAUDE_TIER_MODELS[1], 'gpt-4o-mini', 'gemini-flash'],
         requiresNetwork: true,
         complexityRange: [10, 35],
     },
@@ -63,7 +64,7 @@ export const TIER_METADATA = {
         ],
         typicalLatencyMs: 3000,
         relativeCost: 2,
-        exampleModels: ['claude-sonnet-4-6', 'gpt-4o', 'gemini-pro'],
+        exampleModels: [DEFAULT_SONNET_MODEL, 'gpt-4o', 'gemini-pro'],
         requiresNetwork: true,
         complexityRange: [35, 70],
     },
@@ -79,7 +80,7 @@ export const TIER_METADATA = {
         ],
         typicalLatencyMs: 7000,
         relativeCost: 3,
-        exampleModels: ['claude-sonnet-4-6'],
+        exampleModels: [DEFAULT_SONNET_MODEL],
         requiresNetwork: true,
         complexityRange: [60, 85],
     },
@@ -96,7 +97,7 @@ export const TIER_METADATA = {
         ],
         typicalLatencyMs: 5000,
         relativeCost: 4,
-        exampleModels: ['claude-opus-4-7', 'gpt-4-turbo'],
+        exampleModels: [DEFAULT_OPUS_MODEL, 'gpt-4-turbo'],
         requiresNetwork: true,
         complexityRange: [75, 100],
     },
@@ -177,10 +178,7 @@ export const DEFAULT_ROUTER_CONFIG = {
     fallbackTier: 2, // Sonnet as fallback
     tierModels: {
         0: 'agent-booster',
-        1: 'claude-haiku-4-5-20251001',
-        2: 'claude-sonnet-4-6',
-        3: 'claude-sonnet-4-6',
-        4: 'claude-opus-4-7',
+        ...CLAUDE_TIER_MODELS,
     },
 };
 // ============================================================================

package/dist/integrations/agentic-flow/reasoning-bank/index.js

@@ -155,15 +155,6 @@ export class EnhancedReasoningBankAdapter {
                         ...guidance.suggestedActions.map(a => `Action: ${a}`),
                         ...result.guidance,
                     ];
-                    this.stats.tokensSavedEstimate += guidance.estimatedTokenSavings;
-                    this.stats.experiencesApplied++;
-                    // Record application of each source experience for reuse tracking
-                    for (const src of guidance.sourceExperiences) {
-                        this.experienceReplay.recordApplication(src.id, request.task, true, // success=true at routing time; updated later via recordOutcome
-                        Math.round(guidance.estimatedTokenSavings)).catch(err => {
-                            console.warn(`[EnhancedAdapter] Failed to record experience application: ${err}`);
-                        });
-                    }
                 }
             }
             // Find similar past trajectories
@@ -265,17 +256,8 @@ export class EnhancedReasoningBankAdapter {
         if (!this.experienceReplay) {
             return null;
         }
-        const guidance = await this.experienceReplay.getGuidance(task, domain);
-        if (guidance) {
-            this.stats.experiencesApplied++;
-            // Record application for reuse tracking (experience_applications table)
-            for (const src of guidance.sourceExperiences) {
-                this.experienceReplay.recordApplication(src.id, task, true, Math.round(guidance.estimatedTokenSavings)).catch(err => {
-                    console.warn(`[EnhancedAdapter] Failed to record experience application: ${err}`);
-                });
-            }
-        }
-        return guidance;
+        // Retrieving guidance does not establish that it was applied successfully.
+        return this.experienceReplay.getGuidance(task, domain);
     }
     /**
      * Record that an experience was applied
@@ -290,6 +272,7 @@ export class EnhancedReasoningBankAdapter {
         if (!this.experienceReplay)
             return;
         await this.experienceReplay.recordApplication(experienceId, task, success, tokensSaved);
+        this.stats.experiencesApplied++;
         this.stats.tokensSavedEstimate += tokensSaved;
     }
     // ============================================================================

package/dist/integrations/coherence/engines/cohomology-adapter.js

@@ -19,6 +19,10 @@ import { WasmNotLoadedError, DEFAULT_COHERENCE_LOGGER } from '../types.js';
 // ============================================================================
 // WASM Engine Wrapper
 // ============================================================================
+// Dense restriction maps are copied into WASM. Bound each native call to
+// 32 MiB of matrix cells and 256 MiB of cumulative cells per operation.
+const MAX_NATIVE_BATCH_CELLS = 4 * 1024 * 1024;
+const MAX_NATIVE_TOTAL_CELLS = 32 * 1024 * 1024;
 /**
  * Creates an ICohomologyEngine wrapper around the raw WASM engine
  * Translates from snake_case adapter interface to camelCase WASM API
@@ -53,19 +57,78 @@ function createCohomologyEngineWrapper(rawEngine) {
     // WASM sheaf cohomology expects:
     // { nodes: [{id: number, label: string, section: number[], weight: number}], edges: [...] }
     // "section" is the sheaf theory term for local data at each stalk
-    const buildGraph = () => ({
-        nodes: Array.from(nodes.entries()).map(([id, data]) => ({
-            id: getOrCreateIndex(id), // Convert string ID to numeric index
-            label: id, // Original string ID as label
-            section: Array.from(data.embedding), // Sheaf section = the embedding data
-            weight: 1.0, // Node weight (importance) - default to 1.0
-        })),
-        edges: edges.map(e => ({
-            source: getOrCreateIndex(e.source), // Convert to numeric
-            target: getOrCreateIndex(e.target), // Convert to numeric
-            weight: e.weight,
-        })),
-    });
+    function* buildGraphs() {
+        // Native edge endpoints address the current nodes array by position, not
+        // node.id. Rebuild indices after removals or edges added before nodes.
+        stringToIndex.clear();
+        indexToString.clear();
+        nextIndex = 0;
+        const dimension = nodes.values().next().value?.embedding.length;
+        const graphNodes = Array.from(nodes.entries()).map(([id, data]) => {
+            if (data.embedding.length !== dimension) {
+                throw new RangeError('Cohomology graphs require matching embedding dimensions');
+            }
+            return {
+                id: getOrCreateIndex(id),
+                label: id,
+                section: Array.from(data.embedding),
+                weight: 1.0,
+            };
+        });
+        // Validate the complete operation before allocating any dense matrices or
+        // calling WASM. A rejected graph must never yield partial energy/results.
+        let totalCells = 0;
+        const preparedEdges = edges.map(edge => {
+            const source = nodes.get(edge.source);
+            const target = nodes.get(edge.target);
+            if (!source || !target) {
+                throw new Error(`Cohomology edge references an unknown node: ${edge.source} -> ${edge.target}`);
+            }
+            const dimension = source.embedding.length;
+            const cells = dimension * dimension;
+            if (cells > MAX_NATIVE_BATCH_CELLS) {
+                throw new RangeError(`Cohomology restriction map exceeds ${MAX_NATIVE_BATCH_CELLS} cells`);
+            }
+            totalCells += cells;
+            if (totalCells > MAX_NATIVE_TOTAL_CELLS) {
+                throw new RangeError(`Cohomology graph exceeds ${MAX_NATIVE_TOTAL_CELLS} restriction-map cells`);
+            }
+            return { ...edge, dimension, cells };
+        });
+        let batch = [];
+        let batchCells = 0;
+        const restrictionMaps = new Map();
+        for (const edge of preparedEdges) {
+            if (batchCells + edge.cells > MAX_NATIVE_BATCH_CELLS) {
+                yield { nodes: graphNodes, edges: batch };
+                batch = [];
+                batchCells = 0;
+                restrictionMaps.clear();
+            }
+            let restrictionMap = restrictionMaps.get(edge.dimension);
+            if (!restrictionMap) {
+                // Sections share embedding coordinates; use a row-major identity map.
+                // Sharing the read-only JS matrix avoids per-edge JS allocations.
+                restrictionMap = Array(edge.cells).fill(0);
+                for (let i = 0; i < edge.dimension; i++) {
+                    restrictionMap[i * edge.dimension + i] = 1;
+                }
+                restrictionMaps.set(edge.dimension, restrictionMap);
+            }
+            batch.push({
+                source: stringToIndex.get(edge.source),
+                target: stringToIndex.get(edge.target),
+                weight: edge.weight,
+                restriction_map: restrictionMap,
+                source_dim: edge.dimension,
+                target_dim: edge.dimension,
+            });
+            batchCells += edge.cells;
+        }
+        if (batch.length > 0 || preparedEdges.length === 0) {
+            yield { nodes: graphNodes, edges: batch };
+        }
+    }
     return {
         add_node(id, embedding) {
             nodes.set(id, { embedding });
@@ -79,8 +142,7 @@ function createCohomologyEngineWrapper(rawEngine) {
         },
         remove_node(id) {
             nodes.delete(id);
-            // Note: We don't remove from index mappings to maintain consistency
-            // (indices are reused to avoid graph corruption)
+            // Native indices are rebuilt from current node order on serialization.
             // Remove associated edges
             for (let i = edges.length - 1; i >= 0; i--) {
                 if (edges[i].source === id || edges[i].target === id) {
@@ -94,22 +156,30 @@ function createCohomologyEngineWrapper(rawEngine) {
                 edges.splice(idx, 1);
         },
         sheaf_laplacian_energy() {
-            const graph = buildGraph();
-            return rawEngine.consistencyEnergy(graph);
+            // Native consistency energy is the sum of independent edge energies.
+            let energy = 0;
+            for (const graph of buildGraphs()) {
+                energy += rawEngine.consistencyEnergy(graph);
+            }
+            return energy;
         },
         detect_contradictions(threshold) {
-            const graph = buildGraph();
-            const obstructions = rawEngine.detectObstructions(graph);
-            if (!obstructions)
-                return [];
-            return obstructions
-                .filter(o => o.energy > threshold)
-                .map(o => ({
-                node1: getStringId(o.node1), // Convert back to string ID
-                node2: getStringId(o.node2), // Convert back to string ID
-                severity: o.energy,
-                distance: o.energy,
-            }));
+            const contradictions = [];
+            for (const graph of buildGraphs()) {
+                const obstructions = rawEngine.detectObstructions(graph);
+                for (const obstruction of obstructions ?? []) {
+                    if (obstruction.magnitude > threshold) {
+                        contradictions.push({
+                            node1: getStringId(obstruction.source_node),
+                            node2: getStringId(obstruction.target_node),
+                            severity: obstruction.magnitude,
+                            distance: obstruction.magnitude,
+                        });
+                    }
+                }
+            }
+            // Preserve the native global descending-magnitude order across batches.
+            return contradictions.sort((a, b) => b.distance - a.distance);
         },
         clear() {
             nodes.clear();
@@ -297,7 +367,7 @@ export class CohomologyAdapter {
             nodeIds: [raw.node1, raw.node2],
             severity: this.severityFromDistance(raw.severity),
             description: this.generateContradictionDescription(raw),
-            confidence: 1 - raw.distance, // Higher distance = lower confidence it's a true contradiction
+            confidence: Math.max(0, 1 - raw.distance), // Native magnitudes can exceed one
             resolution: this.suggestResolution(raw),
         };
     }

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

@@ -20,7 +20,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { safeJsonParse } from '../../shared/safe-json.js';
-import { sha256, queryAll, queryIterator, countRows, domainFilterForColumn, writeJsonl, writeJsonlStreaming, readJsonl, ensureTargetTables, serializeRowBlobs, deserializeRowBlobs, mergeGenericRow, mergeAppendOnlyRow, TABLE_CONFIGS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, } from './brain-shared.js';
+import { sha256, queryAll, queryIterator, countRows, domainFilterForColumn, writeJsonl, writeJsonlStreaming, readJsonl, runImportTransaction, serializeRowBlobs, deserializeRowBlobs, mergeGenericRow, remapPatternReferences, mergeAppendOnlyRow, TABLE_CONFIGS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, } from './brain-shared.js';
 // ============================================================================
 // Internal helpers
 // ============================================================================
@@ -219,20 +219,13 @@ export function importBrain(db, containerPath, options) {
             'The export may have been tampered with or corrupted.');
     }
     const configs = tablesToImport(manifest.version);
-    if (options.dryRun) {
-        let total = 0;
-        for (const config of configs) {
-            const rows = readJsonl(join(dir, config.fileName), safeJsonParse);
-            total += rows.length;
-        }
-        return { imported: total, skipped: 0, conflicts: 0 };
-    }
-    ensureTargetTables(db);
     let imported = 0;
     let skipped = 0;
     let conflicts = 0;
     // Wrap entire import in a transaction for atomicity (Risk #3 from plan)
-    const importAll = db.transaction(() => {
+    const importAll = () => {
+        const patternIds = new Map();
+        const patternWinners = new Map();
         for (const config of configs) {
             const filePath = join(dir, config.fileName);
             let rows = readJsonl(filePath, safeJsonParse);
@@ -240,7 +233,8 @@ export function importBrain(db, containerPath, options) {
             if (config.blobColumns && config.blobColumns.length > 0) {
                 rows = rows.map(r => deserializeRowBlobs(r, config.blobColumns));
             }
-            for (const row of rows) {
+            for (const originalRow of rows) {
+                const row = remapPatternReferences(originalRow, patternIds);
                 let result;
                 if (config.dedupColumns && config.dedupColumns.length > 0) {
                     // Append-only tables (witness_chain, qe_pattern_usage)
@@ -251,15 +245,15 @@ export function importBrain(db, containerPath, options) {
                     const idCol = PK_COLUMNS[config.tableName] || 'id';
                     const tsCol = TIMESTAMP_COLUMNS[config.tableName];
                     const confCol = CONFIDENCE_COLUMNS[config.tableName];
-                    result = mergeGenericRow(db, config.tableName, row, idCol, options.mergeStrategy, tsCol, confCol);
+                    result = mergeGenericRow(db, config.tableName, row, idCol, options.mergeStrategy, tsCol, confCol, patternIds, patternWinners, originalRow.pattern_id);
                 }
                 imported += result.imported;
                 skipped += result.skipped;
                 conflicts += result.conflicts;
             }
         }
-    });
-    importAll();
+    };
+    runImportTransaction(db, options.dryRun ?? false, importAll);
     return { imported, skipped, conflicts };
 }
 // ============================================================================

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

@@ -6,7 +6,7 @@
 import { existsSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'fs';
 import { basename, dirname, join, resolve } from 'path';
 import { createRvfStore, openRvfStore, openRvfStoreReadonly, isRvfNativeAvailable, } from './rvf-native-adapter.js';
-import { sha256, tableExists, queryAll, domainFilterForColumn, ensureTargetTables, mergeGenericRow, mergeAppendOnlyRow, TABLE_CONFIGS, TABLE_BLOB_COLUMNS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, serializeRowBlobs, deserializeRowBlobs, } from './brain-shared.js';
+import { sha256, tableExists, queryAll, domainFilterForColumn, runImportTransaction, mergeGenericRow, remapPatternReferences, mergeAppendOnlyRow, TABLE_CONFIGS, TABLE_BLOB_COLUMNS, PK_COLUMNS, CONFIDENCE_COLUMNS, TIMESTAMP_COLUMNS, serializeRowBlobs, deserializeRowBlobs, } from './brain-shared.js';
 // --- Export ---
 /**
  * Sidecar suffixes that make up a complete store on disk. `''` is the store
@@ -355,7 +355,7 @@ export function importBrainFromRvf(db, rvfPath, options) {
         throw new Error(`RVF file not found: ${filePath}`);
     }
     // Open read-write so compact() can reclaim space after conflict resolution (4.5)
-    const rvf = openRvfStore(filePath);
+    const rvf = options.dryRun ? openRvfStoreReadonly(filePath) : openRvfStore(filePath);
     try {
         // --- Verify HNSW index integrity before importing (4.1) ---
         // Fresh RVF files report valid=false with totalEntries=0 and no errors —
@@ -379,22 +379,6 @@ export function importBrainFromRvf(db, rvfPath, options) {
         catch (parseErr) {
             throw new Error(`Failed to parse brain kernel data as JSON: ${parseErr instanceof Error ? parseErr.message : parseErr}`);
         }
-        if (options.dryRun) {
-            let total = 0;
-            if (brainData.tables) {
-                for (const rows of Object.values(brainData.tables)) {
-                    total += (rows?.length ?? 0);
-                }
-            }
-            else {
-                total = (brainData.patterns?.length ?? 0) +
-                    (brainData.qValues?.length ?? 0) +
-                    (brainData.dreamInsights?.length ?? 0) +
-                    (brainData.witnessChain?.length ?? 0);
-            }
-            return { imported: total, skipped: 0, conflicts: 0, embeddingsRestored: 0 };
-        }
-        ensureTargetTables(db);
         let imported = 0;
         let skipped = 0;
         let conflicts = 0;
@@ -414,7 +398,9 @@ export function importBrainFromRvf(db, rvfPath, options) {
             }
         }
         // Wrap entire import in a transaction for atomicity (Risk #3 from plan)
-        const importAll = db.transaction(() => {
+        const importAll = () => {
+            const patternIds = new Map();
+            const patternWinners = new Map();
             // Import in TABLE_CONFIGS order (FK-aware)
             for (const config of TABLE_CONFIGS) {
                 let rows = tablesMap[config.tableName];
@@ -424,14 +410,9 @@ export function importBrainFromRvf(db, rvfPath, options) {
                 const blobCols = TABLE_BLOB_COLUMNS[config.tableName];
                 if (blobCols && blobCols.length > 0) {
                     rows = rows.map(r => deserializeRowBlobs(r, blobCols));
-                    for (const row of rows) {
-                        for (const col of blobCols) {
-                            if (row[col] instanceof Buffer)
-                                embeddingsRestored++;
-                        }
-                    }
                 }
-                for (const row of rows) {
+                for (const originalRow of rows) {
+                    const row = remapPatternReferences(originalRow, patternIds);
                     let result;
                     if (config.dedupColumns && config.dedupColumns.length > 0) {
                         result = mergeAppendOnlyRow(db, config.tableName, row, config.dedupColumns, config.preserveId);
@@ -440,17 +421,23 @@ export function importBrainFromRvf(db, rvfPath, options) {
                         const idCol = PK_COLUMNS[config.tableName] || 'id';
                         const tsCol = TIMESTAMP_COLUMNS[config.tableName];
                         const confCol = CONFIDENCE_COLUMNS[config.tableName];
-                        result = mergeGenericRow(db, config.tableName, row, idCol, options.mergeStrategy, tsCol, confCol);
+                        result = mergeGenericRow(db, config.tableName, row, idCol, options.mergeStrategy, tsCol, confCol, patternIds, patternWinners, originalRow.pattern_id);
+                    }
+                    if (result.imported) {
+                        for (const col of blobCols ?? []) {
+                            if (row[col] instanceof Buffer)
+                                embeddingsRestored++;
+                        }
                     }
                     imported += result.imported;
                     skipped += result.skipped;
                     conflicts += result.conflicts;
                 }
             }
-        });
-        importAll();
+        };
+        runImportTransaction(db, options.dryRun ?? false, importAll);
         // Compact after conflict resolution (best-effort)
-        if (conflicts > 0) {
+        if (!options.dryRun && conflicts > 0) {
             try {
                 rvf.compact();
             }

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

@@ -131,11 +131,13 @@ export declare function writeJsonl(filePath: string, rows: unknown[]): void;
  */
 export declare function writeJsonlStreaming(filePath: string, rows: Iterable<unknown>, transform?: (row: unknown) => unknown): number;
 export declare function readJsonl<T = unknown>(filePath: string, parser?: (line: string) => T): T[];
+/** Remap relational pattern references without rewriting signed witness payloads. */
+export declare function remapPatternReferences(row: Record<string, unknown>, patternIds: ReadonlyMap<string, string>): Record<string, unknown>;
 /**
  * Generic merge for tables with a TEXT PRIMARY KEY.
  * Uses strategy-based conflict resolution identical to the pattern-specific merges.
  */
-export declare function mergeGenericRow(db: Database.Database, tableName: string, row: Record<string, unknown>, idColumn: string, strategy: MergeStrategy, timestampColumn?: string, confidenceColumn?: string): MergeResult;
+export declare function mergeGenericRow(db: Database.Database, tableName: string, row: Record<string, unknown>, idColumn: string, strategy: MergeStrategy, timestampColumn?: string, confidenceColumn?: string, patternIds?: Map<string, string>, patternWinners?: Map<string, string | null>, originalPatternId?: unknown): MergeResult;
 /**
  * Merge for append-only tables (AUTOINCREMENT PK).
  * Deduplicates by checking composite columns; inserts if no match found.
@@ -154,4 +156,6 @@ export declare function updateDreamInsight(db: Database.Database, ins: DreamInsi
 export declare function insertWitnessEntry(db: Database.Database, entry: WitnessRow): void;
 /** Ensure all brain-related tables exist in the target database. */
 export declare function ensureTargetTables(db: Database.Database): void;
+/** Execute the real importer; dry runs roll back rows and schema, including nested calls. */
+export declare function runImportTransaction(db: Database.Database, dryRun: boolean, importer: () => void): void;
 //# sourceMappingURL=brain-shared.d.ts.map

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

@@ -190,6 +190,16 @@ export function readJsonl(filePath, parser = (line) => JSON.parse(line)) {
         return [];
     return content.split('\n').map(parser);
 }
+/** Remap relational pattern references without rewriting signed witness payloads. */
+export function remapPatternReferences(row, patternIds) {
+    const mapped = { ...row };
+    for (const column of ['pattern_id', 'source_pattern_id', 'target_pattern_id']) {
+        const id = mapped[column];
+        if (typeof id === 'string' && patternIds.has(id))
+            mapped[column] = patternIds.get(id);
+    }
+    return mapped;
+}
 // --- Generic merge for TEXT PK tables ---
 /** Dynamically insert a row into any table using its column keys. */
 function dynamicInsert(db, tableName, row) {
@@ -212,18 +222,57 @@ function dynamicUpdate(db, tableName, row, idColumn) {
  * Generic merge for tables with a TEXT PRIMARY KEY.
  * Uses strategy-based conflict resolution identical to the pattern-specific merges.
  */
-export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestampColumn, confidenceColumn) {
+export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestampColumn, confidenceColumn, patternIds, patternWinners, originalPatternId) {
     const validated = validateTableName(tableName);
+    const incomingId = String(row.id);
     if (!tableExists(db, validated)) {
         dynamicInsert(db, validated, row);
         return { imported: 1, skipped: 0, conflicts: 0 };
     }
-    const existing = db.prepare(`SELECT * FROM ${validated} WHERE ${idColumn} = ?`)
+    let existing = db.prepare(`SELECT * FROM ${validated} WHERE ${idColumn} = ?`)
         .get(row[idColumn]);
+    if (!existing && tableName === 'qe_patterns') {
+        existing = db.prepare('SELECT * FROM qe_patterns WHERE name = ? AND qe_domain = ? AND pattern_type = ?').get(row.name, row.qe_domain, row.pattern_type);
+    }
+    if (existing && tableName === 'qe_patterns') {
+        // Keep the destination identity: existing children must remain attached,
+        // and incoming children are remapped after all patterns have merged.
+        if (typeof row.id === 'string' && typeof existing.id === 'string') {
+            patternIds?.set(row.id, existing.id);
+        }
+        row = { ...row, id: existing.id };
+        if (!patternWinners?.has(String(existing.id)))
+            patternWinners?.set(String(existing.id), null);
+    }
+    if (tableName === 'qe_pattern_embeddings' && patternWinners?.has(String(row.pattern_id))) {
+        if (patternWinners.get(String(row.pattern_id)) !== originalPatternId) {
+            return { imported: 0, skipped: 1, conflicts: existing ? 1 : 0 };
+        }
+        if (existing)
+            dynamicUpdate(db, validated, row, idColumn);
+        else
+            dynamicInsert(db, validated, row);
+        return { imported: 1, skipped: 0, conflicts: existing ? 1 : 0 };
+    }
     if (!existing) {
+        if (tableName === 'qe_patterns')
+            patternWinners?.set(String(row.id), incomingId);
         dynamicInsert(db, validated, row);
         return { imported: 1, skipped: 0, conflicts: 0 };
     }
+    const replaceExisting = () => {
+        if (tableName === 'qe_patterns' && patternWinners) {
+            patternWinners.set(String(row.id), incomingId);
+            // An embedding describes pattern content, not its confidence or usage.
+            // Keep a valid vector for metadata-only updates when no vector is supplied.
+            const contentColumns = ['name', 'description', 'pattern_type', 'qe_domain', 'domain', 'template_json', 'context_json'];
+            if (contentColumns.some(column => Object.hasOwn(row, column) && (row[column] ?? null) !== (existing[column] ?? null)) &&
+                tableExists(db, 'qe_pattern_embeddings')) {
+                db.prepare('DELETE FROM qe_pattern_embeddings WHERE pattern_id = ?').run(row.id);
+            }
+        }
+        dynamicUpdate(db, validated, row, idColumn);
+    };
     switch (strategy) {
         case 'skip-conflicts':
             return { imported: 0, skipped: 1, conflicts: 1 };
@@ -232,7 +281,7 @@ export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestam
             const existingTime = existing[ts] || '';
             const incomingTime = row[ts] || '';
             if (incomingTime > existingTime) {
-                dynamicUpdate(db, validated, row, idColumn);
+                replaceExisting();
                 return { imported: 1, skipped: 0, conflicts: 1 };
             }
             return { imported: 0, skipped: 1, conflicts: 1 };
@@ -241,7 +290,7 @@ export function mergeGenericRow(db, tableName, row, idColumn, strategy, timestam
             const cc = confidenceColumn || 'confidence';
             if (typeof row[cc] === 'number' && typeof existing[cc] === 'number') {
                 if (row[cc] > existing[cc]) {
-                    dynamicUpdate(db, validated, row, idColumn);
+                    replaceExisting();
                     return { imported: 1, skipped: 0, conflicts: 1 };
                 }
             }
@@ -349,4 +398,21 @@ export function insertWitnessEntry(db, entry) {
 export function ensureTargetTables(db) {
     ensureAllBrainTables(db);
 }
+/** Execute the real importer; dry runs roll back rows and schema, including nested calls. */
+export function runImportTransaction(db, dryRun, importer) {
+    const rollback = Symbol('brain import dry run');
+    const transaction = db.transaction(() => {
+        ensureTargetTables(db);
+        importer();
+        if (dryRun)
+            throw rollback;
+    });
+    try {
+        transaction();
+    }
+    catch (error) {
+        if (error !== rollback)
+            throw error;
+    }
+}
 //# sourceMappingURL=brain-shared.js.map