sqlite-local-ai-memory 0.0.0-stage → 1.4.4

package/dist/sqlite_store.js

@@ -0,0 +1,409 @@
+/**
+ * ============================================================================
+ * FILE: src/memory/sqlite_store.ts
+ * RESPONSIBILITY: Bare-Metal In-Process SQLite Persistence Engine.
+ * INTEGRATION: FTS5 BM25 exact matching + Int8 Quantized Vector Cosine (<1.5ms).
+ *
+ * JOURNAL MODE (SQLITE_JOURNAL_MODE env var, default: TRUNCATE):
+ *   - TRUNCATE (default): safe for network/NFS/cloud-mounted disks where WAL
+ *     shared-memory files (-shm/-wal) can cause corruption. mmap is disabled.
+ *   - WAL: best for local SSD/NVMe — activates 256MB mmap and concurrent reads.
+ *     Use only when the database file lives on a local filesystem.
+ * ============================================================================
+ */
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as path from "path";
+import os from "os";
+import { EMBEDDING_DIM } from "./types.js";
+const LOCAL_FALLBACK_PATH = path.join(os.homedir(), ".local-ai-memory", "memoria.db");
+export const DASHBOARD_UUID = "00000000-0000-0000-0000-000000000000";
+export class SqliteStore {
+    db;
+    dbPath;
+    constructor(targetPath) {
+        const rawPath = targetPath || process.env.SQLITE_MEM_PATH;
+        this.dbPath = this.resolveDatabasePath(rawPath);
+        this.db = this.initDatabase(this.dbPath);
+    }
+    expandHome(filepath) {
+        const trimmed = filepath.trim();
+        if (trimmed === "~")
+            return os.homedir();
+        if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+            return path.join(os.homedir(), trimmed.slice(2));
+        }
+        return trimmed;
+    }
+    resolveDatabasePath(customPath) {
+        if (!customPath)
+            return LOCAL_FALLBACK_PATH;
+        const expandedPath = this.expandHome(customPath);
+        try {
+            const dir = path.dirname(expandedPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            return expandedPath;
+        }
+        catch (err) {
+            console.error(`⚠️ [SQLITE_STORE] Database path "${expandedPath}" unusable (${err.message}). ` +
+                `Falling back to: ${LOCAL_FALLBACK_PATH}`);
+            return LOCAL_FALLBACK_PATH;
+        }
+    }
+    initDatabase(dbPath) {
+        const dir = path.dirname(dbPath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const journalMode = (process.env.SQLITE_JOURNAL_MODE || "TRUNCATE").toUpperCase();
+        const busyTimeout = parseInt(process.env.SQLITE_BUSY_TIMEOUT || "5000", 10);
+        const db = new Database(dbPath, { timeout: busyTimeout });
+        db.pragma(`busy_timeout = ${busyTimeout}`);
+        try {
+            // FIX R3-1.2: better-sqlite3 returns an Array of row objects, not a plain object.
+            const rows = db.pragma("journal_mode");
+            const currentMode = rows?.[0]?.journal_mode?.toUpperCase() || "";
+            if (currentMode !== journalMode) {
+                db.pragma(`journal_mode = ${journalMode}`);
+            }
+        }
+        catch (err) {
+            console.error("⚠️ [SQLITE_STORE] Could not verify/set journal_mode:", err.message);
+        }
+        db.pragma("synchronous = NORMAL");
+        if (journalMode === "WAL") {
+            db.pragma("mmap_size = 268435456");
+        }
+        else {
+            db.pragma("mmap_size = 0");
+            if (journalMode !== "TRUNCATE") {
+                // TRUNCATE is the intentional default — only warn for unexpected modes.
+                console.error(`⚠️ [SQLITE_STORE] journal_mode=${journalMode} + synchronous=NORMAL: ` +
+                    `mmap disabled. For local SSD/NVMe use SQLITE_JOURNAL_MODE=WAL.`);
+            }
+        }
+        db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS recuerdos_fts USING fts5(
+        point_id UNINDEXED,
+        user_id UNINDEXED,
+        data,
+        source,
+        created_at UNINDEXED,
+        tokenize = 'unicode61 remove_diacritics 1'
+      );
+
+      CREATE TABLE IF NOT EXISTS recuerdos_vectores (
+        point_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        data TEXT NOT NULL,
+        source TEXT DEFAULT 'system',
+        created_at TEXT NOT NULL,
+        vector_blob BLOB,
+        PRIMARY KEY (point_id, user_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_recuerdos_user_id ON recuerdos_vectores (user_id);
+      CREATE INDEX IF NOT EXISTS idx_recuerdos_source ON recuerdos_vectores (source);
+      CREATE INDEX IF NOT EXISTS idx_recuerdos_created_at ON recuerdos_vectores (created_at);
+    `);
+        return db;
+    }
+    quantizeVectorInt8(vec) {
+        let norm = 0;
+        for (let i = 0; i < vec.length; i++)
+            norm += vec[i] * vec[i];
+        norm = Math.sqrt(norm);
+        const scale = norm > 0 ? 1.0 / norm : 1.0;
+        const buf = Buffer.alloc(vec.length);
+        for (let i = 0; i < vec.length; i++) {
+            const normalized = vec[i] * scale;
+            const val = Math.max(-127, Math.min(127, Math.round(normalized * 127.0)));
+            buf.writeInt8(val, i);
+        }
+        return buf;
+    }
+    cosineSimilarityInt8(queryVec, blob) {
+        if (!blob || blob.length !== queryVec.length)
+            return 0;
+        let dotProduct = 0;
+        let normQ = 0;
+        let normB = 0;
+        for (let i = 0; i < queryVec.length; i++) {
+            const q = queryVec[i];
+            const b = blob.readInt8(i) / 127.0;
+            dotProduct += q * b;
+            normQ += q * q;
+            normB += b * b;
+        }
+        if (normQ === 0 || normB === 0)
+            return 0;
+        return dotProduct / (Math.sqrt(normQ) * Math.sqrt(normB));
+    }
+    /** Static stopword set for ES/EN — filters common words that dilute FTS5 BM25 ranking. */
+    static STOPWORDS = new Set([
+        // Spanish
+        "de", "la", "el", "en", "que", "es", "lo", "un", "una", "las", "los",
+        "del", "al", "por", "con", "para", "se", "su", "sus", "le", "les",
+        "ya", "me", "te", "mi", "tu", "nos", "como", "pero", "mas", "ese",
+        "esa", "eso", "esta", "este", "esto", "son", "fue", "ser", "hay",
+        "si", "no", "muy", "sin", "sobre", "entre", "cuando", "donde",
+        "desde", "hasta", "era", "han", "sido", "tiene", "puede",
+        "tambien", "otro", "otra", "otros", "cada", "todo", "toda", "todos",
+        // English
+        "the", "is", "at", "which", "on", "a", "an", "and", "or", "but",
+        "in", "with", "for", "to", "of", "it", "its", "was", "are", "be",
+        "has", "had", "have", "do", "does", "did", "not", "this", "that",
+        "from", "by", "as", "into", "can", "will", "just", "about", "also",
+        "been", "would", "should", "could", "than", "then", "them", "they",
+        "their", "there", "what", "when", "how", "who", "all", "some",
+    ]);
+    searchFTS5(query, limit = 10, userId) {
+        try {
+            const sanitized = query.replace(/[^a-zA-Z0-9\u00C0-\u024F\s]/g, " ").trim();
+            const cleanWords = sanitized
+                .split(/\s+/)
+                .map((w) => w.trim())
+                .filter((w) => w.length > 1 && !SqliteStore.STOPWORDS.has(w.toLowerCase()));
+            if (cleanWords.length === 0)
+                return [];
+            const ftsQuery = cleanWords.map((w) => `"${w}"*`).join(" OR ");
+            let rows;
+            if (userId) {
+                const stmt = this.db.prepare(`
+          SELECT point_id as id, user_id, data, source, created_at, rank
+          FROM recuerdos_fts
+          WHERE recuerdos_fts MATCH ? AND user_id = ?
+          ORDER BY rank LIMIT ?
+        `);
+                rows = stmt.all(ftsQuery, userId, limit);
+            }
+            else {
+                const stmt = this.db.prepare(`
+          SELECT point_id as id, user_id, data, source, created_at, rank
+          FROM recuerdos_fts
+          WHERE recuerdos_fts MATCH ?
+          ORDER BY rank LIMIT ?
+        `);
+                rows = stmt.all(ftsQuery, limit);
+            }
+            return rows.map((r) => ({
+                id: String(r.id),
+                user_id: String(r.user_id),
+                data: String(r.data),
+                memory: String(r.data),
+                source: String(r.source),
+                created_at: String(r.created_at),
+                rank: typeof r.rank === "number" ? r.rank : undefined,
+            }));
+        }
+        catch (error) {
+            console.error("[SQLITE_STORE] Error in FTS5 search:", error.message);
+            return [];
+        }
+    }
+    searchVectorInt8(queryVec, limit = 10, userId) {
+        try {
+            let rows;
+            if (userId) {
+                const stmt = this.db.prepare(`
+          SELECT point_id as id, user_id, data, source, created_at, vector_blob
+          FROM recuerdos_vectores
+          WHERE vector_blob IS NOT NULL
+            AND point_id != ?
+            AND source != 'inactive'
+            AND user_id = ?
+          ORDER BY created_at DESC
+          LIMIT 5000
+        `);
+                rows = stmt.all(DASHBOARD_UUID, userId);
+                if (rows.length >= 5000) {
+                    console.error(`⚠️ [SQLITE_STORE] Vector scan hit the 5000-row safety limit for user [${userId}]. Consider enabling ANN indexing for better scalability.`);
+                }
+            }
+            else {
+                const stmt = this.db.prepare(`
+          SELECT point_id as id, user_id, data, source, created_at, vector_blob
+          FROM recuerdos_vectores
+          WHERE vector_blob IS NOT NULL
+            AND point_id != ?
+            AND source != 'inactive'
+          ORDER BY created_at DESC
+          LIMIT 5000
+        `);
+                rows = stmt.all(DASHBOARD_UUID);
+                if (rows.length >= 5000) {
+                    console.error(`⚠️ [SQLITE_STORE] Vector scan hit the 5000-row safety limit. Consider enabling ANN indexing for better scalability.`);
+                }
+            }
+            const scored = [];
+            for (const r of rows) {
+                if (r.vector_blob && Buffer.isBuffer(r.vector_blob)) {
+                    const score = this.cosineSimilarityInt8(queryVec, r.vector_blob);
+                    scored.push({
+                        id: String(r.id),
+                        user_id: String(r.user_id),
+                        data: String(r.data),
+                        memory: String(r.data),
+                        source: String(r.source),
+                        created_at: String(r.created_at),
+                        score,
+                    });
+                }
+            }
+            scored.sort((a, b) => (b.score || 0) - (a.score || 0));
+            return scored.slice(0, limit);
+        }
+        catch (error) {
+            console.error("[SQLITE_STORE] Error in Int8 vector search:", error.message);
+            return [];
+        }
+    }
+    insertMemoryFact(id, data, userId = "user_default", vector, source = "system") {
+        try {
+            const now = new Date().toISOString();
+            const vectorBlob = vector && vector.length === EMBEDDING_DIM ? this.quantizeVectorInt8(vector) : null;
+            const targetUser = userId || "user_default";
+            const deleteFts = this.db.prepare(`DELETE FROM recuerdos_fts WHERE point_id = ?`);
+            const insertFts = this.db.prepare(`
+        INSERT INTO recuerdos_fts (point_id, user_id, data, source, created_at)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+            const insertVec = this.db.prepare(`
+        INSERT OR REPLACE INTO recuerdos_vectores (point_id, user_id, data, source, created_at, vector_blob)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+            this.db.transaction(() => {
+                deleteFts.run(id);
+                insertFts.run(id, targetUser, data.trim(), source, now);
+                insertVec.run(id, targetUser, data.trim(), source, now, vectorBlob);
+            })();
+            return true;
+        }
+        catch (error) {
+            console.error("[SQLITE_STORE] Error inserting fact:", error.message);
+            return false;
+        }
+    }
+    deactivateMemoryFact(id) {
+        if (id === DASHBOARD_UUID)
+            return false;
+        try {
+            const deleteFts = this.db.prepare("DELETE FROM recuerdos_fts WHERE point_id = ?");
+            const updateVec = this.db.prepare("UPDATE recuerdos_vectores SET vector_blob = NULL, source = 'inactive' WHERE point_id = ?");
+            this.db.transaction(() => {
+                deleteFts.run(id);
+                updateVec.run(id);
+            })();
+            return true;
+        }
+        catch (error) {
+            console.error("[SQLITE_STORE] Error deactivating fact:", error.message);
+            return false;
+        }
+    }
+    getDashboardFact(userId = "user_default") {
+        try {
+            const row = this.db.prepare(`
+        SELECT data, created_at as updated_at
+        FROM recuerdos_vectores
+        WHERE point_id = ? AND user_id = ?
+      `).get(DASHBOARD_UUID, userId);
+            if (row && row.data) {
+                return {
+                    data: String(row.data),
+                    memory: String(row.data),
+                    updated_at: String(row.updated_at || "")
+                };
+            }
+        }
+        catch (error) {
+            console.error("[SQLITE_STORE] Error reading Dashboard:", error.message);
+        }
+        return null;
+    }
+    saveDashboardFact(dashboardJson, userId = "user_default", vector) {
+        try {
+            const now = new Date().toISOString();
+            const vectorBlob = vector && vector.length === EMBEDDING_DIM ? this.quantizeVectorInt8(vector) : null;
+            this.db.prepare(`
+        INSERT OR REPLACE INTO recuerdos_vectores (point_id, user_id, data, source, created_at, vector_blob)
+        VALUES (?, ?, ?, 'lo_ultimo', ?, ?)
+      `).run(DASHBOARD_UUID, userId, dashboardJson, now, vectorBlob);
+            return true;
+        }
+        catch (error) {
+            console.error("[SQLITE_STORE] Error saving Dashboard:", error.message);
+            return false;
+        }
+    }
+    /**
+     * Retrieves recent memory facts created on or after the specified timestamp.
+     * Excludes the Dashboard global singleton record (DASHBOARD_UUID).
+     *
+     * @param sinceIso - ISO 8601 timestamp string marking the start of the consolidation window.
+     * @param userId - Target user identifier (defaults to 'user_default').
+     * @param sourceFilter - Optional case-insensitive source label filter (e.g. 'TOTALCONNECT').
+     * @returns Array of objects containing the fact text (`data`) and its origin (`source`).
+     */
+    getRecentFactsSince(sinceIso, userId = "user_default", sourceFilter) {
+        try {
+            let query = `
+        SELECT data, source
+        FROM recuerdos_vectores
+        WHERE user_id = ? AND point_id != ?
+          AND created_at >= ?
+          AND source != 'inactive'
+      `;
+            const params = [userId, DASHBOARD_UUID, sinceIso];
+            if (sourceFilter) {
+                query += ` AND UPPER(source) = ?`;
+                params.push(sourceFilter.toUpperCase());
+            }
+            query += ` ORDER BY created_at ASC`;
+            const rows = this.db.prepare(query).all(...params);
+            return rows.map((r) => ({
+                data: String(r.data),
+                source: String(r.source || "system"),
+            }));
+        }
+        catch (error) {
+            console.error("[SQLITE_STORE] Error retrieving recent facts:", error.message);
+            return [];
+        }
+    }
+    async backfillMissingVectors(getEmbeddingFn, userId = "user_default") {
+        try {
+            const rows = this.db.prepare(`
+        SELECT point_id, data
+        FROM recuerdos_vectores
+        WHERE user_id = ? AND vector_blob IS NULL AND source != 'inactive' AND point_id != ?
+        LIMIT 25
+      `).all(userId, DASHBOARD_UUID);
+            if (rows.length === 0)
+                return 0;
+            let backfilled = 0;
+            for (const r of rows) {
+                const vec = await getEmbeddingFn(String(r.data));
+                if (vec && vec.length === EMBEDDING_DIM) {
+                    const blob = this.quantizeVectorInt8(vec);
+                    this.db.prepare(`
+            UPDATE recuerdos_vectores SET vector_blob = ? WHERE point_id = ?
+          `).run(blob, String(r.point_id));
+                    backfilled++;
+                }
+            }
+            if (backfilled > 0) {
+                console.error(`✨ [LAZY_BACKFILL] Generated Int8 vector embeddings for ${backfilled} past un-vectorized facts.`);
+            }
+            return backfilled;
+        }
+        catch (e) {
+            return 0;
+        }
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+        }
+    }
+}

package/dist/stress_test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stress_test.d.ts.map

package/dist/stress_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stress_test.d.ts","sourceRoot":"","sources":["../src/stress_test.ts"],"names":[],"mappings":""}

package/dist/stress_test.js

@@ -0,0 +1,149 @@
+/**
+ * ============================================================================
+ * FILE: src/memory/stress_test.ts
+ * RESPONSIBILITY: Comprehensive 26-Test Stress Suite (Real-World Read/Write,
+ * Noise Filtering, Semantic Collision Resolution, and AutoDream Consolidation).
+ * ============================================================================
+ */
+import fs from "fs";
+import { MemoryEngine } from "./MemoryEngine.js";
+async function runStressTest() {
+    console.log("🚀 [STRESS_TEST] Starting 26-Test Intensive Live Suite on MemoryEngine...\n");
+    const testDbPath = "./memoria_stress.db";
+    for (const ext of ["", "-wal", "-shm"]) {
+        if (fs.existsSync(testDbPath + ext)) {
+            try {
+                fs.unlinkSync(testDbPath + ext);
+            }
+            catch (_) { }
+        }
+    }
+    const memory = new MemoryEngine({
+        dbPath: testDbPath,
+        userName: "User Alice",
+    });
+    let totalTests = 0;
+    let successfulTests = 0;
+    function assertTest(name, condition, details) {
+        totalTests++;
+        if (condition) {
+            successfulTests++;
+            console.log(`✅ [TEST ${totalTests}] ${name} ${details ? `(${details})` : ""}`);
+        }
+        else {
+            console.error(`❌ [TEST ${totalTests}] FAILED: ${name} ${details ? `(${details})` : ""}`);
+        }
+    }
+    try {
+        // ------------------------------------------------------------------------
+        // BLOCK 1: Noise & Greeting Filtering (Gatekeeper) - 5 Tests
+        // ------------------------------------------------------------------------
+        console.log("--- BLOCK 1: Noise & Greeting Filtering (Agent: Gatekeeper) ---");
+        await memory.save("hello good afternoon");
+        assertTest("Regex Filter: Hello good afternoon", (await memory.search("hello")).length === 0);
+        await memory.save("ok thanks got it");
+        assertTest("Regex Filter: ok thanks got it", (await memory.search("thanks")).length === 0);
+        await memory.save("hahahahaha sounds good cool");
+        assertTest("Regex Filter: laughter and empty confirmation", (await memory.search("sounds")).length === 0);
+        await memory.save("sure sounds good to me");
+        assertTest("Regex Filter: sure sounds good to me", (await memory.search("sure")).length === 0);
+        await memory.save("got it all set");
+        assertTest("Regex Filter: got it all set", (await memory.search("all set")).length === 0);
+        // ------------------------------------------------------------------------
+        // BLOCK 2: Atomic Fact Extraction (Notary) - 5 Tests
+        // ------------------------------------------------------------------------
+        console.log("\n--- BLOCK 2: Atomic Fact Extraction (Agent: Notary) ---");
+        await memory.save("Primary server Proxmox is active on IP 10.0.0.200");
+        const h1 = await memory.search("Proxmox IP 10.0.0.200");
+        assertTest("Notary: Extract Proxmox IP .200", h1.length > 0 && h1[0].data.includes("10.0.0.200"));
+        await memory.save("User Alice likes to drink double espresso coffee in the morning");
+        const h2 = await memory.search("espresso coffee");
+        assertTest("Notary: Coffee preference", h2.length > 0 && h2[0].data.includes("espresso"));
+        await memory.save("Secondary AdGuard Home container is hosted on IP 10.0.0.96");
+        const h3 = await memory.search("AdGuard IP 10.0.0.96");
+        assertTest("Notary: AdGuard IP .96", h3.length > 0 && h3[0].data.includes("10.0.0.96"));
+        await memory.save("User Bob prefers not to work in noisy environments");
+        const h4 = await memory.search("User Bob noisy environments");
+        assertTest("Notary: Preference of User Bob", h4.length > 0 && h4[0].data.includes("User Bob"));
+        await memory.save("SnapRAID backup script runs daily at 02:00 AM");
+        const h5 = await memory.search("SnapRAID 02:00 AM");
+        assertTest("Notary: SnapRAID schedule", h5.length > 0 && h5[0].data.includes("SnapRAID"));
+        // ------------------------------------------------------------------------
+        // BLOCK 3: Additive Facts (Context Coexistence) - 4 Tests
+        // ------------------------------------------------------------------------
+        console.log("\n--- BLOCK 3: Additive Facts (Context Coexistence) ---");
+        await memory.save("User Alice also likes drinking green tea in the afternoon");
+        const hAdd1 = await memory.search("espresso coffee or green tea");
+        assertTest("Additive Facts: Coffee and Tea Coexist", hAdd1.length >= 2, `Retrieved ${hAdd1.length} facts`);
+        await memory.save("Proxmox server also hosts virtual machine VM 101 Tiny11");
+        const hAdd2 = await memory.search("Proxmox VM 101 Tiny11");
+        assertTest("Additive Facts: Proxmox hosts VM 101", hAdd2.length > 0);
+        await memory.save("User Bob prefers studying programming in Python");
+        const hAdd3 = await memory.search("User Bob Python");
+        assertTest("Additive Facts: User Bob studies Python", hAdd3.length > 0);
+        await memory.save("SnapRAID includes parity on backup disk /mnt/parity");
+        const hAdd4 = await memory.search("SnapRAID /mnt/parity");
+        assertTest("Additive Facts: SnapRAID parity", hAdd4.length > 0);
+        // ------------------------------------------------------------------------
+        // BLOCK 4: Semantic Arbiter (Soft-Deletes & State Replacement) - 5 Tests
+        // ------------------------------------------------------------------------
+        console.log("\n--- BLOCK 4: Semantic Arbiter (Soft-Deletes & State Replacement) ---");
+        await memory.save("Secondary AdGuard Home container was moved to new IP 10.0.0.97");
+        const hCol1 = await memory.search("AdGuard Home IP");
+        assertTest("Semantic Arbiter: AdGuard IP updated to .97", hCol1.length > 0 && hCol1[0].data.includes("10.0.0.97"));
+        await memory.save("JottaCloud sync service was temporarily paused for maintenance");
+        const hCol2 = await memory.search("JottaCloud maintenance");
+        assertTest("Semantic Arbiter: JottaCloud paused state", hCol2.length > 0 && hCol2[0].data.includes("paused"));
+        await memory.save("JottaCloud sync service was resumed and is 100% operational");
+        const hCol3 = await memory.search("JottaCloud operational");
+        assertTest("Semantic Arbiter: JottaCloud resumed state", hCol3.length > 0 && hCol3[0].data.includes("operational"));
+        await memory.save("User Alice is currently at the office");
+        const hCol4 = await memory.search("User Alice location office");
+        assertTest("Semantic Arbiter: Alice location at office", hCol4.length > 0 && hCol4[0].data.includes("office"));
+        await memory.save("User Alice has returned home");
+        const hCol5 = await memory.search("User Alice location home");
+        assertTest("Semantic Arbiter: Alice location at home", hCol5.length > 0 && hCol5[0].data.includes("home"));
+        // ------------------------------------------------------------------------
+        // BLOCK 5: Dual Hybrid Search (FTS5 BM25 + Int8 Vector) - 4 Tests
+        // ------------------------------------------------------------------------
+        console.log("\n--- BLOCK 5: Dual Hybrid Search (FTS5 BM25 + Int8 Vector) ---");
+        const search1 = await memory.search("10.0.0.200", 3);
+        assertTest("Exact Dual Search IP: 10.0.0.200", search1.length > 0 && (search1[0].score || 0) >= 0.5, `Score: ${search1[0]?.score?.toFixed(2)}`);
+        const search2 = await memory.search("What beverages does Alice prefer?", 3);
+        assertTest("Semantic Dual Search: Alice beverages", search2.length > 0, `Facts found: ${search2.length}`);
+        const search3 = await memory.search("User Bob programming preferences", 3);
+        assertTest("Compound Dual Search: User Bob", search3.length > 0, `Facts found: ${search3.length}`);
+        const search4 = await memory.search("SnapRAID parity and schedule", 3);
+        assertTest("Compound Dual Search: SnapRAID", search4.length > 0, `Facts found: ${search4.length}`);
+        // ------------------------------------------------------------------------
+        // BLOCK 6: AutoDream State Orchestrator (Dashboard Consolidation) - 3 Tests
+        // ------------------------------------------------------------------------
+        console.log("\n--- BLOCK 6: AutoDream State Orchestrator (Dashboard Consolidation) ---");
+        const autoDreamResult = await memory.consolidate();
+        assertTest("AutoDream: Consolidation Execution", autoDreamResult.statusMessage.includes("AutoDream") || autoDreamResult.narrativeSummary.length > 0, autoDreamResult.statusMessage);
+        const dashboardObj = memory.getDashboard();
+        assertTest("Dashboard: Read Consolidated State", dashboardObj !== null && dashboardObj.data.length > 0, `Active dashboard: ${dashboardObj?.updated_at}`);
+        const searchFinal = await memory.search("server state summary", 3);
+        assertTest("Final Search after AutoDream", searchFinal.length > 0);
+        // ------------------------------------------------------------------------
+        // FINAL SUMMARY
+        // ------------------------------------------------------------------------
+        console.log("\n==========================================================================");
+        console.log(`📊 FINAL STRESS TEST SUMMARY: ${successfulTests} / ${totalTests} TESTS PASSED (${((successfulTests / totalTests) * 100).toFixed(1)}%)`);
+        console.log("==========================================================================");
+        if (successfulTests < totalTests) {
+            console.error(`💥 ${totalTests - successfulTests} test(s) failed.`);
+            // FIX R3-1.5: set exitCode instead of calling process.exit() so the
+            // finally block below always runs and closes the SQLite connection cleanly.
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        console.error("❌ Fatal error during test suite:", error.message);
+        process.exitCode = 1;
+    }
+    finally {
+        memory.close();
+    }
+}
+runStressTest();

package/dist/test_autodream_dual.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test_autodream_dual.d.ts.map

package/dist/test_autodream_dual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_autodream_dual.d.ts","sourceRoot":"","sources":["../src/test_autodream_dual.ts"],"names":[],"mappings":""}

package/dist/test_autodream_dual.js

@@ -0,0 +1,38 @@
+import { MemoryEngine } from "./MemoryEngine.js";
+import * as fs from "fs";
+async function runTest() {
+    console.log("🧪 [TEST] Testing AutoDream Dual Output & Memory Triage...");
+    const dbPath = "./memoria_test_dual.db";
+    for (const ext of ["", "-wal", "-shm"]) {
+        if (fs.existsSync(dbPath + ext)) {
+            try {
+                fs.unlinkSync(dbPath + ext);
+            }
+            catch (_) { }
+        }
+    }
+    const memory = new MemoryEngine({
+        dbPath,
+        userName: "Alice",
+        userId: "user_test",
+        semanticArbitrator: true,
+    });
+    console.log("\n📥 Ingesting test facts...");
+    await memory.saveFact("[DEVELOPMENT] [NETWORK] Socket reconnection error 256X resolved by adding delay before resumable calls.");
+    await memory.saveFact("[DIAGNOSIS] Investigating server overheating root cause under heavy load. Solution pending.");
+    console.log("\n⚙️ Executing AutoDream consolidation (memory.consolidate())...");
+    const result = await memory.consolidate("user_test");
+    console.log("\n📊 DUAL RESULT COLLECTED:");
+    console.log("--------------------------------------------------");
+    console.log("🔹 Narrative Summary (Dashboard):", result.narrativeSummary);
+    console.log("\n🔹 Dashboard Items (Working State):", JSON.stringify(result.dashboard, null, 2));
+    console.log("\n🔹 Triage Memory (Long-term SQLite Facts):", JSON.stringify(result.triageMemory, null, 2));
+    console.log("\n🔹 Open Cases (Incubator):", JSON.stringify(result.openCases, null, 2));
+    console.log("--------------------------------------------------");
+    memory.close();
+    console.log("\n✅ Test completed successfully.");
+}
+runTest().catch((err) => {
+    console.error("❌ Test error:", err);
+    process.exit(1);
+});

package/dist/test_autodream_history.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test_autodream_history.d.ts.map

package/dist/test_autodream_history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_autodream_history.d.ts","sourceRoot":"","sources":["../src/test_autodream_history.ts"],"names":[],"mappings":""}