agentic-qe 3.7.21 → 3.8.0

package/dist/kernel/native-hnsw-backend.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Native HNSW Backend via @ruvector/router VectorDb
+ *
+ * Provides a high-performance HNSW index backed by the Rust-based
+ * @ruvector/router library. This backend implements the same
+ * IHnswIndexProvider interface as ProgressiveHnswBackend but delegates
+ * vector storage and search to native code for lower latency and
+ * higher throughput.
+ *
+ * When @ruvector/router is unavailable (e.g., unsupported platform,
+ * missing binary), construction throws NativeHnswUnavailableError so the
+ * caller (HnswAdapter factory) can fall back to the JS backend.
+ *
+ * @see ADR-081: Native HNSW NAPI Integration
+ * @module kernel/native-hnsw-backend
+ */
+import type { IHnswIndexProvider, SearchResult, HnswConfig } from './hnsw-index-provider.js';
+/**
+ * Thrown when @ruvector/router native binary is not available.
+ * The HnswAdapter factory catches this to fall back to the JS backend.
+ */
+export declare class NativeHnswUnavailableError extends Error {
+    constructor(reason: string);
+}
+/**
+ * Reset the native module loader state.
+ * Useful for testing fallback behavior.
+ */
+export declare function resetNativeModuleLoader(): void;
+/**
+ * Check if the native module is available without throwing.
+ */
+export declare function isNativeModuleAvailable(): boolean;
+export interface NativeHnswMetrics {
+    totalSearches: number;
+    totalAdds: number;
+    totalRemoves: number;
+    avgSearchLatencyMs: number;
+    maxSearchLatencyMs: number;
+    lastSearchLatencyMs: number;
+    fallbackSearchCount: number;
+    bruteForceSearchCount: number;
+    nativeSearchCount: number;
+    fallbackRate: number;
+    allSearchesBruteForce: boolean;
+}
+/**
+ * Native HNSW backend using @ruvector/router VectorDb.
+ *
+ * Provides the same IHnswIndexProvider interface as ProgressiveHnswBackend
+ * but delegates all vector operations to a Rust-based HNSW implementation
+ * for improved performance.
+ *
+ * Note: @ruvector/router VectorDb uses string IDs while IHnswIndexProvider
+ * uses numeric IDs. Conversion is done via String(id) and Number(id).
+ * VectorDb search returns distance scores (lower = closer) which are
+ * converted to similarity scores (higher = closer) for consistency.
+ */
+export declare class NativeHnswBackend implements IHnswIndexProvider {
+    private readonly config;
+    private nativeDb;
+    private readonly metadataStore;
+    private readonly vectorStore;
+    private readonly normStore;
+    private operationLock;
+    private highFallbackWarningEmitted;
+    private _metrics;
+    /**
+     * Create a NativeHnswBackend.
+     *
+     * @param config - HNSW configuration overrides
+     * @throws {NativeHnswUnavailableError} If @ruvector/router is not available
+     */
+    constructor(config?: Partial<HnswConfig>);
+    add(id: number, vector: Float32Array, metadata?: Record<string, unknown>): void;
+    search(query: Float32Array, k: number): SearchResult[];
+    remove(id: number): boolean;
+    size(): number;
+    dimensions(): number;
+    recall(): number;
+    /**
+     * Get performance metrics for this index.
+     */
+    getMetrics(): Readonly<NativeHnswMetrics>;
+    /**
+     * Get last search latency in milliseconds.
+     */
+    get lastSearchLatencyMs(): number;
+    /**
+     * Get the current configuration.
+     */
+    getConfig(): Readonly<HnswConfig>;
+    /**
+     * Clear all vectors from the index.
+     * Deletes all entries from the native VectorDb.
+     */
+    clear(): void;
+    /**
+     * Check if the native backend is operational.
+     */
+    isNativeAvailable(): boolean;
+    private normalizeVector;
+    private updateSearchMetrics;
+    /**
+     * Brute-force fallback search over locally stored vectors.
+     * Used when native search throws an unexpected error.
+     */
+    private bruteForceSearch;
+}
+//# sourceMappingURL=native-hnsw-backend.d.ts.map

package/dist/kernel/native-hnsw-backend.js

@@ -0,0 +1,408 @@
+/**
+ * Native HNSW Backend via @ruvector/router VectorDb
+ *
+ * Provides a high-performance HNSW index backed by the Rust-based
+ * @ruvector/router library. This backend implements the same
+ * IHnswIndexProvider interface as ProgressiveHnswBackend but delegates
+ * vector storage and search to native code for lower latency and
+ * higher throughput.
+ *
+ * When @ruvector/router is unavailable (e.g., unsupported platform,
+ * missing binary), construction throws NativeHnswUnavailableError so the
+ * caller (HnswAdapter factory) can fall back to the JS backend.
+ *
+ * @see ADR-081: Native HNSW NAPI Integration
+ * @module kernel/native-hnsw-backend
+ */
+import { createRequire } from 'module';
+import { DEFAULT_HNSW_CONFIG } from './hnsw-index-provider.js';
+// Use createRequire for @ruvector/router (native CJS/NAPI module)
+const esmRequire = createRequire(import.meta.url);
+// ============================================================================
+// Error Types
+// ============================================================================
+/**
+ * Thrown when @ruvector/router native binary is not available.
+ * The HnswAdapter factory catches this to fall back to the JS backend.
+ */
+export class NativeHnswUnavailableError extends Error {
+    constructor(reason) {
+        super(`Native HNSW backend unavailable: ${reason}`);
+        this.name = 'NativeHnswUnavailableError';
+    }
+}
+// ============================================================================
+// Native Module Loader
+// ============================================================================
+let nativeModule = null;
+let nativeLoadAttempted = false;
+let nativeLoadError = null;
+/**
+ * Attempt to load the @ruvector/router native module.
+ * Caches the result so subsequent calls are instant.
+ */
+function loadNativeModule() {
+    if (nativeLoadAttempted) {
+        if (nativeModule)
+            return nativeModule;
+        throw new NativeHnswUnavailableError(nativeLoadError ?? 'Unknown load error');
+    }
+    nativeLoadAttempted = true;
+    try {
+        // Use createRequire for the optional native NAPI dependency
+        const mod = esmRequire('@ruvector/router');
+        // Verify the module has the expected API
+        if (!mod.VectorDb || !mod.DistanceMetric) {
+            throw new Error('@ruvector/router module missing VectorDb or DistanceMetric exports');
+        }
+        nativeModule = mod;
+        return nativeModule;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        nativeLoadError = message;
+        throw new NativeHnswUnavailableError(message);
+    }
+}
+/**
+ * Reset the native module loader state.
+ * Useful for testing fallback behavior.
+ */
+export function resetNativeModuleLoader() {
+    nativeModule = null;
+    nativeLoadAttempted = false;
+    nativeLoadError = null;
+}
+/**
+ * Check if the native module is available without throwing.
+ */
+export function isNativeModuleAvailable() {
+    try {
+        loadNativeModule();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// Vector Math Helpers
+// ============================================================================
+function computeNorm(v) {
+    let sum = 0;
+    for (let i = 0; i < v.length; i++)
+        sum += v[i] * v[i];
+    return Math.sqrt(sum);
+}
+function fastCosineSimilarity(a, b, normA, normB) {
+    const denom = normA * normB;
+    if (denom === 0)
+        return 0;
+    let dot = 0;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++)
+        dot += a[i] * b[i];
+    return dot / denom;
+}
+/**
+ * Resize a vector to the target dimensions.
+ * Shrink: average adjacent values. Grow: zero-pad.
+ */
+function resizeVector(vector, targetDim) {
+    if (vector.length === targetDim)
+        return vector;
+    const result = new Float32Array(targetDim);
+    if (vector.length > targetDim) {
+        const ratio = vector.length / targetDim;
+        for (let i = 0; i < targetDim; i++) {
+            const start = Math.floor(i * ratio);
+            const end = Math.floor((i + 1) * ratio);
+            let sum = 0;
+            for (let j = start; j < end; j++) {
+                sum += vector[j];
+            }
+            result[i] = sum / (end - start);
+        }
+    }
+    else {
+        for (let i = 0; i < vector.length; i++) {
+            result[i] = vector[i];
+        }
+    }
+    return result;
+}
+// ============================================================================
+// NativeHnswBackend
+// ============================================================================
+/**
+ * Native HNSW backend using @ruvector/router VectorDb.
+ *
+ * Provides the same IHnswIndexProvider interface as ProgressiveHnswBackend
+ * but delegates all vector operations to a Rust-based HNSW implementation
+ * for improved performance.
+ *
+ * Note: @ruvector/router VectorDb uses string IDs while IHnswIndexProvider
+ * uses numeric IDs. Conversion is done via String(id) and Number(id).
+ * VectorDb search returns distance scores (lower = closer) which are
+ * converted to similarity scores (higher = closer) for consistency.
+ */
+export class NativeHnswBackend {
+    config;
+    nativeDb = null;
+    metadataStore = new Map();
+    vectorStore = new Map();
+    normStore = new Map();
+    operationLock = Promise.resolve();
+    highFallbackWarningEmitted = false;
+    _metrics = {
+        totalSearches: 0,
+        totalAdds: 0,
+        totalRemoves: 0,
+        avgSearchLatencyMs: 0,
+        maxSearchLatencyMs: 0,
+        lastSearchLatencyMs: 0,
+        fallbackSearchCount: 0,
+        bruteForceSearchCount: 0,
+        nativeSearchCount: 0,
+        fallbackRate: 0,
+        allSearchesBruteForce: false,
+    };
+    /**
+     * Create a NativeHnswBackend.
+     *
+     * @param config - HNSW configuration overrides
+     * @throws {NativeHnswUnavailableError} If @ruvector/router is not available
+     */
+    constructor(config) {
+        this.config = { ...DEFAULT_HNSW_CONFIG, ...config };
+        // Attempt to load native module and create VectorDb immediately.
+        // If the native module is unavailable or the database can't be opened,
+        // this throws NativeHnswUnavailableError so the factory can fall back
+        // to ProgressiveHnswBackend.
+        const native = loadNativeModule();
+        const distanceMetric = this.config.metric === 'cosine'
+            ? native.DistanceMetric.Cosine
+            : native.DistanceMetric.Euclidean;
+        try {
+            this.nativeDb = new native.VectorDb({
+                dimensions: this.config.dimensions,
+                distanceMetric,
+                hnswM: this.config.M,
+                hnswEfConstruction: this.config.efConstruction,
+                hnswEfSearch: this.config.efSearch,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new NativeHnswUnavailableError(`VectorDb creation failed: ${message}`);
+        }
+    }
+    // ============================================================================
+    // IHnswIndexProvider Implementation
+    // ============================================================================
+    add(id, vector, metadata) {
+        const normalized = this.normalizeVector(vector);
+        const norm = computeNorm(normalized);
+        // Remove existing entry if updating
+        if (this.vectorStore.has(id)) {
+            try {
+                this.nativeDb.delete(String(id));
+            }
+            catch { /* ignore if not found */ }
+        }
+        this.nativeDb.insert(String(id), normalized);
+        this.vectorStore.set(id, normalized);
+        this.normStore.set(id, norm);
+        if (metadata) {
+            this.metadataStore.set(id, metadata);
+        }
+        this._metrics.totalAdds++;
+    }
+    search(query, k) {
+        const start = performance.now();
+        if (this.vectorStore.size === 0)
+            return [];
+        const normalizedQuery = this.normalizeVector(query);
+        const queryNorm = computeNorm(normalizedQuery);
+        const actualK = Math.min(k, this.vectorStore.size);
+        let results;
+        try {
+            const nativeResults = this.nativeDb.search(normalizedQuery, actualK);
+            // Convert native distance scores to similarity scores.
+            // @ruvector/router returns { id: string, score: number } where
+            // score is a distance (lower = closer). We convert string IDs
+            // back to numbers and compute cosine similarity for consistency.
+            results = nativeResults.map((nr) => {
+                const numericId = Number(nr.id);
+                const storedVector = this.vectorStore.get(numericId);
+                const storedNorm = this.normStore.get(numericId) ?? 0;
+                // Compute cosine similarity for consistent scoring with ProgressiveHnswBackend
+                let score;
+                if (this.config.metric === 'cosine' && storedVector) {
+                    score = fastCosineSimilarity(normalizedQuery, storedVector, queryNorm, storedNorm);
+                }
+                else {
+                    // For euclidean, negate the distance (higher = closer)
+                    score = -nr.score;
+                }
+                return {
+                    id: numericId,
+                    score,
+                    metadata: this.metadataStore.get(numericId),
+                };
+            });
+            // Sort by descending score for consistency
+            results.sort((a, b) => b.score - a.score);
+            this._metrics.nativeSearchCount++;
+        }
+        catch {
+            // If native search fails, fall back to brute-force over stored vectors
+            this._metrics.fallbackSearchCount++;
+            this._metrics.bruteForceSearchCount++;
+            console.warn(`[NativeHNSW] FALLBACK: Using brute-force linear scan (@ruvector/router search failed). Index size: ${this.vectorStore.size}`);
+            results = this.bruteForceSearch(normalizedQuery, queryNorm, actualK);
+        }
+        const elapsed = performance.now() - start;
+        this.updateSearchMetrics(elapsed);
+        // Compute derived fallback metrics
+        this._metrics.fallbackRate =
+            this._metrics.fallbackSearchCount / this._metrics.totalSearches;
+        this._metrics.allSearchesBruteForce =
+            this._metrics.nativeSearchCount === 0 && this._metrics.totalSearches > 0;
+        // One-time warning when fallback rate is dangerously high
+        if (!this.highFallbackWarningEmitted &&
+            this._metrics.fallbackRate > 0.5 &&
+            this._metrics.totalSearches >= 10) {
+            this.highFallbackWarningEmitted = true;
+            console.error(`[NativeHNSW] WARNING: ${(this._metrics.fallbackRate * 100).toFixed(0)}% of searches are using brute-force fallback. Native HNSW may not be functioning correctly. Consider rebuilding the index or checking @ruvector/router installation.`);
+        }
+        if (elapsed > 50) {
+            console.warn(`[NativeHNSW] search took ${elapsed.toFixed(1)}ms (k=${k}, results=${results.length})`);
+        }
+        return results;
+    }
+    remove(id) {
+        if (!this.vectorStore.has(id))
+            return false;
+        try {
+            this.nativeDb.delete(String(id));
+        }
+        catch {
+            // Native remove failed; clean up local state anyway
+        }
+        this.vectorStore.delete(id);
+        this.normStore.delete(id);
+        this.metadataStore.delete(id);
+        this._metrics.totalRemoves++;
+        return true;
+    }
+    size() {
+        return this.vectorStore.size;
+    }
+    dimensions() {
+        return this.config.dimensions;
+    }
+    recall() {
+        // HNSW is approximate, estimate recall based on efSearch/M ratio
+        // Higher efSearch relative to M means better recall
+        const ratio = this.config.efSearch / this.config.M;
+        if (ratio >= 10)
+            return 0.99;
+        if (ratio >= 5)
+            return 0.97;
+        if (ratio >= 3)
+            return 0.95;
+        return 0.90;
+    }
+    // ============================================================================
+    // Public Utilities
+    // ============================================================================
+    /**
+     * Get performance metrics for this index.
+     */
+    getMetrics() {
+        return { ...this._metrics };
+    }
+    /**
+     * Get last search latency in milliseconds.
+     */
+    get lastSearchLatencyMs() {
+        return this._metrics.lastSearchLatencyMs;
+    }
+    /**
+     * Get the current configuration.
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Clear all vectors from the index.
+     * Deletes all entries from the native VectorDb.
+     */
+    clear() {
+        // Delete all entries from native DB
+        for (const id of this.vectorStore.keys()) {
+            try {
+                this.nativeDb.delete(String(id));
+            }
+            catch { /* ignore */ }
+        }
+        this.vectorStore.clear();
+        this.normStore.clear();
+        this.metadataStore.clear();
+    }
+    /**
+     * Check if the native backend is operational.
+     */
+    isNativeAvailable() {
+        return this.nativeDb !== null;
+    }
+    // ============================================================================
+    // Private Helpers
+    // ============================================================================
+    normalizeVector(vector) {
+        if (vector.length === this.config.dimensions)
+            return vector;
+        return resizeVector(vector, this.config.dimensions);
+    }
+    updateSearchMetrics(latencyMs) {
+        this._metrics.totalSearches++;
+        this._metrics.lastSearchLatencyMs = latencyMs;
+        if (latencyMs > this._metrics.maxSearchLatencyMs) {
+            this._metrics.maxSearchLatencyMs = latencyMs;
+        }
+        // Running average
+        const n = this._metrics.totalSearches;
+        this._metrics.avgSearchLatencyMs =
+            this._metrics.avgSearchLatencyMs * ((n - 1) / n) + latencyMs / n;
+    }
+    /**
+     * Brute-force fallback search over locally stored vectors.
+     * Used when native search throws an unexpected error.
+     */
+    bruteForceSearch(query, queryNorm, k) {
+        const scored = [];
+        for (const [id, vector] of this.vectorStore) {
+            const norm = this.normStore.get(id) ?? computeNorm(vector);
+            const score = this.config.metric === 'cosine'
+                ? fastCosineSimilarity(query, vector, queryNorm, norm)
+                : -(function () {
+                    let sum = 0;
+                    const len = Math.min(query.length, vector.length);
+                    for (let i = 0; i < len; i++) {
+                        const diff = query[i] - vector[i];
+                        sum += diff * diff;
+                    }
+                    return Math.sqrt(sum);
+                })();
+            scored.push({
+                id,
+                score,
+                metadata: this.metadataStore.get(id),
+            });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, k);
+    }
+}
+//# sourceMappingURL=native-hnsw-backend.js.map

package/dist/kernel/unified-memory.js

@@ -21,7 +21,7 @@
  * - unified-memory-hnsw.ts: HNSW index + BinaryHeap
  * - unified-memory.ts: UnifiedMemoryManager class (this file, facade)
  */
-import Database from 'better-sqlite3';
+import { openDatabase as openSafeDatabase } from '../shared/safe-db.js';
 import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import * as fs from 'fs';
@@ -278,13 +278,12 @@ export class UnifiedMemoryManager {
                     dbSizeBefore = newest.size;
                 }
             }
-            this.db = new Database(this.config.dbPath);
-            if (this.config.walMode) {
-                this.db.pragma('journal_mode = WAL');
-            }
+            this.db = openSafeDatabase(this.config.dbPath, {
+                walMode: this.config.walMode,
+                busyTimeout: this.config.busyTimeout,
+            });
             this.db.pragma(`mmap_size = ${this.config.mmapSize}`);
             this.db.pragma(`cache_size = ${this.config.cacheSize}`);
-            this.db.pragma(`busy_timeout = ${this.config.busyTimeout}`);
             this.db.pragma('foreign_keys = ON');
             await this.runMigrations();
             // DATA LOSS PREVENTION: After migration, if the DB existed before and was

package/dist/learning/aqe-learning-engine.d.ts

@@ -123,6 +123,8 @@ export declare class AQELearningEngine {
     private patternStore?;
     private coherenceService?;
     private initialized;
+    private _domainTransferEngine;
+    private _domainTransferInterval;
     private activeTasks;
     private completedTasks;
     private claudeFlowErrors;

package/dist/learning/aqe-learning-engine.js

@@ -73,6 +73,9 @@ export class AQELearningEngine {
     patternStore;
     coherenceService;
     initialized = false;
+    // Cross-domain transfer (Y-2 wiring)
+    _domainTransferEngine = null;
+    _domainTransferInterval = null;
     // Task tracking
     activeTasks = new Map();
     completedTasks = 0;
@@ -125,6 +128,63 @@ export class AQELearningEngine {
                 promotionThreshold: this.config.promotionThreshold,
             });
             await this.experienceCapture.initialize();
+            // Wire persistent witness chain when feature flag is on
+            try {
+                const { isWitnessChainFeatureEnabled } = await import('../governance/witness-chain.js');
+                if (isWitnessChainFeatureEnabled()) {
+                    const { createPersistentWitnessChain, createWitnessChainSQLitePersistence } = await import('../governance/witness-chain.js');
+                    const { getUnifiedPersistence } = await import('../kernel/unified-persistence.js');
+                    const persistence = getUnifiedPersistence();
+                    if (persistence.isInitialized()) {
+                        const db = persistence.getDatabase();
+                        const chainPersistence = createWitnessChainSQLitePersistence(db);
+                        const chain = createPersistentWitnessChain(chainPersistence);
+                        this.experienceCapture.setWitnessChain(chain);
+                    }
+                }
+            }
+            catch (e) {
+                if (process.env.DEBUG)
+                    console.debug('[AQELearningEngine] Witness chain wiring skipped:', e instanceof Error ? e.message : e);
+            }
+        }
+        // Wire cross-domain transfer with real performance provider (Y-2 fix)
+        try {
+            const { isCrossDomainTransferEnabled } = await import('../integrations/ruvector/feature-flags.js');
+            if (isCrossDomainTransferEnabled() && this.patternStore) {
+                const { createDomainTransferEngine } = await import('../integrations/ruvector/domain-transfer.js');
+                const transferEngine = createDomainTransferEngine();
+                // Pre-fetch stats for the synchronous performance provider callback
+                const store = this.patternStore;
+                let cachedStats = await store.getStats();
+                // Refresh cache periodically in background
+                this._domainTransferInterval = setInterval(async () => {
+                    try {
+                        cachedStats = await store.getStats();
+                    }
+                    catch (e) {
+                        if (process.env.DEBUG)
+                            console.debug('[AQELearningEngine] Stats refresh failed:', e instanceof Error ? e.message : e);
+                    }
+                }, 60_000);
+                this._domainTransferInterval.unref?.();
+                transferEngine.setPerformanceProvider((domain) => {
+                    const domainPatterns = cachedStats.byDomain?.[domain] ?? 0;
+                    const totalPatterns = cachedStats.totalPatterns ?? 0;
+                    return {
+                        domain,
+                        successRate: totalPatterns > 0 ? domainPatterns / totalPatterns : 0.5,
+                        avgConfidence: cachedStats.avgConfidence ?? 0.5,
+                        patternCount: domainPatterns,
+                        timestamp: Date.now(),
+                    };
+                });
+                this._domainTransferEngine = transferEngine;
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[AQELearningEngine] Domain transfer wiring skipped:', e instanceof Error ? e.message : e);
         }
         // Try to initialize Claude Flow bridge (optional)
         if (this.config.enableClaudeFlow) {
@@ -802,6 +862,11 @@ export class AQELearningEngine {
      * Dispose the engine
      */
     async dispose() {
+        if (this._domainTransferInterval) {
+            clearInterval(this._domainTransferInterval);
+            this._domainTransferInterval = null;
+        }
+        this._domainTransferEngine = null;
         if (this.experienceCapture) {
             await this.experienceCapture.dispose();
         }

package/dist/learning/experience-capture-middleware.js

@@ -170,6 +170,26 @@ async function doInitialize() {
         CREATE INDEX IF NOT EXISTS idx_captured_exp_agent ON captured_experiences(agent);
         CREATE INDEX IF NOT EXISTS idx_captured_exp_completed ON captured_experiences(completed_at DESC);
       `);
+            // Add consolidation columns if missing (needed by ExperienceConsolidator)
+            const colNames = new Set(db.prepare('PRAGMA table_info(captured_experiences)').all().map(c => c.name));
+            const consolidationCols = [
+                ['application_count', 'INTEGER DEFAULT 0'],
+                ['avg_token_savings', 'REAL DEFAULT 0'],
+                ['embedding', 'BLOB'],
+                ['embedding_dimension', 'INTEGER'],
+                ['tags', 'TEXT'],
+                ['last_applied_at', 'TEXT'],
+                ['consolidated_into', 'TEXT DEFAULT NULL'],
+                ['consolidation_count', 'INTEGER DEFAULT 1'],
+                ['quality_updated_at', 'TEXT DEFAULT NULL'],
+                ['reuse_success_count', 'INTEGER DEFAULT 0'],
+                ['reuse_failure_count', 'INTEGER DEFAULT 0'],
+            ];
+            for (const [col, def] of consolidationCols) {
+                if (!colNames.has(col)) {
+                    db.exec(`ALTER TABLE captured_experiences ADD COLUMN ${col} ${def}`);
+                }
+            }
         }
         // Start periodic cleanup of stale experiences
         startCleanupTimer();