moflo 4.9.37 → 4.10.0

package/dist/src/cli/memory/memory-initializer.js

@@ -1,26 +1,33 @@
 /**
  * V3 Memory Initializer
- * Properly initializes the memory database with sql.js (WASM SQLite)
- * Includes pattern tables, vector embeddings, migration state tracking
+ * Properly initializes the memory database with node:sqlite via the
+ * unified `openDaemonDatabase` factory.
+ * Includes pattern tables, vector embeddings, migration state tracking.
  *
  * ADR-053: Routes through ControllerRegistry → AgentDB v3 when available,
- * falls back to raw sql.js for backwards compatibility.
+ * falls back to a direct node:sqlite write for backwards compatibility.
+ *
+ * Phase 5 (#1084): every `mofloImport('sql.js') + new SQL.Database(buffer)`
+ * triplet (and the matching `atomicWriteFileSync(path, db.export())`) was
+ * replaced with `openDaemonDatabase(path)`. node:sqlite + WAL persists each
+ * mutation incrementally; the explicit whole-file-dump that sql.js needed
+ * was the multi-writer clobber vector epic #1078 killed structurally.
  *
  * @module v3/cli/memory-initializer
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { mofloImport } from '../services/moflo-require.js';
-import { atomicWriteFileSync } from '../services/atomic-file-write.js';
 import { formatEmbeddingError } from './embedding-errors.js';
 import { HnswLite } from './hnsw-lite.js';
 import { tryLoadHnswSidecar } from './hnsw-persistence.js';
 import { EMBEDDING_MODEL_OPT_OUT, EPHEMERAL_NAMESPACES, getBridgeEmbedder } from './bridge-embedder.js';
 import { parseEmbeddingJson, toFloat32 } from './controllers/_shared.js';
 import { writeVectorStatsJson } from './bridge-core.js';
+import { serialiseMetadata } from './bridge-entries.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { MOFLO_DIR, hnswIndexPath, legacyMemoryDbPath, memoryDbPath, } from '../services/moflo-paths.js';
-import { tryDaemonStore, tryDaemonDelete } from './daemon-write-client.js';
+import { tryDaemonStore, tryDaemonDelete, tryDaemonGet, tryDaemonSearch, tryDaemonList } from './daemon-write-client.js';
+import { openDaemonDatabase } from './daemon-backend.js';
 // #981 — daemon-write-client throws are a contract violation (it's documented
 // as never-throw). When a throw escapes anyway, log to stderr ONCE per process
 // and fall through to the direct-write path. Silent swallow would hide bugs;
@@ -34,8 +41,8 @@ function logRoutingFault(err) {
 }
 /**
  * Write vector-stats.json cache for the statusline (no subprocess needed).
- * Called after memory store in the raw-sql.js fallback path. The bridge path
- * goes through refreshVectorStatsCache() in bridge-core.ts instead.
+ * Called after memory store in the direct-write fallback path. The bridge
+ * path goes through refreshVectorStatsCache() in bridge-core.ts instead.
  * @param dbPath - path to the SQLite database file
  * @param stats  - exact counts from a db query already in progress (required —
  *                 making this optional caused issue #639 by silently writing 0)
@@ -428,10 +435,7 @@ export async function getHNSWIndex(options) {
         const SELECT_METADATA_ONLY = `id, key, namespace, content, metadata`;
         if (fs.existsSync(dbPath)) {
             try {
-                const initSqlJs = (await mofloImport('sql.js')).default;
-                const SQL = await initSqlJs();
-                const fileBuffer = fs.readFileSync(dbPath);
-                const sqlDb = new SQL.Database(fileBuffer);
+                const sqlDb = openDaemonDatabase(dbPath);
                 const cols = sidecarLoaded ? SELECT_METADATA_ONLY : SELECT_WITH_EMBEDDING;
                 const result = sqlDb.exec(`
           SELECT ${cols}
@@ -834,10 +838,7 @@ export async function ensureSchemaColumns(dbPath) {
         if (!fs.existsSync(dbPath)) {
             return { success: true, columnsAdded: [] };
         }
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(dbPath);
         // Get current columns in memory_entries
         const tableInfo = db.exec("PRAGMA table_info(memory_entries)");
         const existingColumns = new Set(tableInfo[0]?.values?.map(row => row[1]) || []);
@@ -857,22 +858,17 @@ export async function ensureSchemaColumns(dbPath) {
             { name: 'access_count', definition: 'access_count INTEGER DEFAULT 0' },
             { name: 'status', definition: "status TEXT DEFAULT 'active'" }
         ];
-        let modified = false;
         for (const col of requiredColumns) {
             if (!existingColumns.has(col.name)) {
                 try {
                     db.run(`ALTER TABLE memory_entries ADD COLUMN ${col.definition}`);
                     columnsAdded.push(col.name);
-                    modified = true;
                 }
                 catch (e) {
                     // Column might already exist or other error - continue
                 }
             }
         }
-        if (modified) {
-            atomicWriteFileSync(dbPath, db.export());
-        }
         db.close();
         return { success: true, columnsAdded };
     }
@@ -904,10 +900,7 @@ export async function checkAndMigrateLegacy(options) {
     for (const legacyPath of legacyPaths) {
         if (fs.existsSync(legacyPath) && legacyPath !== dbPath) {
             try {
-                const initSqlJs = (await mofloImport('sql.js')).default;
-                const SQL = await initSqlJs();
-                const legacyBuffer = fs.readFileSync(legacyPath);
-                const legacyDb = new SQL.Database(legacyBuffer);
+                const legacyDb = openDaemonDatabase(legacyPath);
                 // Check if it has data
                 const countResult = legacyDb.exec('SELECT COUNT(*) FROM memory_entries');
                 const count = countResult[0]?.values[0]?.[0] || 0;
@@ -980,7 +973,43 @@ async function activateControllerRegistry(dbPath, verbose) {
     return { activated, failed, initTimeMs: performance.now() - startTime };
 }
 /**
- * Initialize the memory database properly using sql.js
+ * Cross-platform safe unlink with a short EBUSY/EPERM retry loop. Windows
+ * holds file handles briefly after process exit (and the consumer's
+ * background daemon may still own the moflo.db handle when `memory init
+ * --force` runs); on POSIX the first attempt always succeeds. Total wait
+ * is bounded at ~750ms so we never paper over a real long-held handle.
+ *
+ * Used by `initializeMemoryDatabase` to ride out the daemon's brief handle
+ * release race after `flo healer --kill-zombies`. See #1098 for the smoke
+ * harness incident that drove this — the daemon's WAL+SHM file handles
+ * weren't released by Windows for ~200ms after SIGKILL.
+ */
+function unlinkWithRetry(filePath) {
+    const delays = [0, 50, 100, 100, 100, 100, 100, 100, 50, 50]; // ~750ms total
+    let lastErr = null;
+    for (let attempt = 0; attempt < delays.length; attempt++) {
+        if (delays[attempt] > 0)
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delays[attempt]);
+        try {
+            fs.unlinkSync(filePath);
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err?.code;
+            // Only retry on the handle-release race codes. ENOENT means we've
+            // already won (or the file was never there); EACCES could be a real
+            // permission issue worth surfacing immediately.
+            if (code === 'ENOENT')
+                return;
+            if (code !== 'EBUSY' && code !== 'EPERM')
+                throw err;
+        }
+    }
+    throw lastErr;
+}
+/**
+ * Initialize the memory database via the unified node:sqlite factory.
  */
 export async function initializeMemoryDatabase(options) {
     const { backend = 'hybrid', dbPath: customPath, force = false, verbose = false, migrate = true } = options;
@@ -1017,130 +1046,91 @@ export async function initializeMemoryDatabase(options) {
                 error: 'Database already exists. Use --force to reinitialize.'
             };
         }
-        // Try to use sql.js (WASM SQLite)
-        let db;
-        let usedSqlJs = false;
-        try {
-            // Dynamic import of sql.js
-            const initSqlJs = (await mofloImport('sql.js')).default;
-            const SQL = await initSqlJs();
-            // Load existing database or create new
-            if (fs.existsSync(dbPath) && force) {
-                fs.unlinkSync(dbPath);
+        // Force a clean slate so the new file gets fresh WAL state too.
+        if (fs.existsSync(dbPath) && force) {
+            // Windows EBUSY guard (#1098): the consumer's background daemon
+            // (spawned by session-start during `npm install`) holds an open
+            // file handle on moflo.db. `unlinkSync` would otherwise throw EBUSY
+            // immediately — and the OS-level handle release race only resolves
+            // after the daemon process actually exits, so a tight retry loop
+            // can't outwait it. Stop the daemon first (graceful SIGTERM +
+            // 1s grace + SIGKILL via `killBackgroundDaemon`), THEN retry the
+            // unlink to ride out any residual handle-release lag.
+            const projectRoot = path.dirname(path.dirname(dbPath));
+            const { killBackgroundDaemon } = await import('../commands/daemon.js');
+            try {
+                await killBackgroundDaemon(projectRoot);
             }
-            db = new SQL.Database();
-            usedSqlJs = true;
-        }
-        catch (e) {
-            // sql.js not available, fall back to writing schema file
-            if (verbose) {
-                console.log('sql.js not available, writing schema file for later initialization');
+            catch { /* best-effort; the retry below still gives us a budget */ }
+            unlinkWithRetry(dbPath);
+            // Also drop any sidecar WAL files so the next open doesn't replay
+            // stale uncommitted transactions from the previous DB.
+            for (const suffix of ['-wal', '-shm']) {
+                const sidecar = dbPath + suffix;
+                if (fs.existsSync(sidecar)) {
+                    try {
+                        unlinkWithRetry(sidecar);
+                    }
+                    catch { /* best-effort */ }
+                }
             }
         }
-        if (usedSqlJs && db) {
+        const db = openDaemonDatabase(dbPath);
+        try {
             // Execute schema
             db.run(MEMORY_SCHEMA_V3);
             // Insert initial metadata
             db.run(getInitialMetadata(backend));
-            // Save to file
-            const data = db.export();
-            const buffer = Buffer.from(data);
-            fs.writeFileSync(dbPath, buffer);
-            // Close database
-            db.close();
-            // Also create schema file for reference
-            const schemaPath = path.join(dbDir, 'schema.sql');
-            fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
-            // ADR-053: Activate ControllerRegistry so controllers (ReasoningBank,
-            // SkillLibrary, ExplainableRecall, etc.) are instantiated during init
-            const controllerResult = await activateControllerRegistry(dbPath, verbose);
-            return {
-                success: true,
-                backend,
-                dbPath,
-                schemaVersion: '3.0.0',
-                tablesCreated: [
-                    'memory_entries',
-                    'patterns',
-                    'pattern_history',
-                    'trajectories',
-                    'trajectory_steps',
-                    'migration_state',
-                    'sessions',
-                    'vector_indexes',
-                    'metadata'
-                ],
-                indexesCreated: [
-                    'idx_memory_namespace',
-                    'idx_memory_key',
-                    'idx_memory_type',
-                    'idx_memory_status',
-                    'idx_memory_created',
-                    'idx_memory_accessed',
-                    'idx_memory_owner',
-                    'idx_patterns_type',
-                    'idx_patterns_confidence',
-                    'idx_patterns_status',
-                    'idx_patterns_last_matched',
-                    'idx_pattern_history_pattern',
-                    'idx_steps_trajectory'
-                ],
-                features: {
-                    vectorEmbeddings: true,
-                    patternLearning: true,
-                    temporalDecay: true,
-                    hnswIndexing: true,
-                    migrationTracking: true
-                },
-                controllers: controllerResult,
-            };
         }
-        else {
-            // Fall back to schema file approach
-            const schemaPath = path.join(dbDir, 'schema.sql');
-            fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
-            // Create minimal valid SQLite file
-            const sqliteHeader = Buffer.alloc(4096, 0);
-            // SQLite format 3 header
-            Buffer.from('SQLite format 3\0').copy(sqliteHeader, 0);
-            sqliteHeader[16] = 0x10; // page size high byte (4096)
-            sqliteHeader[17] = 0x00; // page size low byte
-            sqliteHeader[18] = 0x01; // file format write version
-            sqliteHeader[19] = 0x01; // file format read version
-            sqliteHeader[24] = 0x00; // max embedded payload
-            sqliteHeader[25] = 0x40;
-            sqliteHeader[26] = 0x20; // min embedded payload
-            sqliteHeader[27] = 0x20; // leaf payload
-            fs.writeFileSync(dbPath, sqliteHeader);
-            // ADR-053: Activate ControllerRegistry even on fallback path
-            const controllerResult = await activateControllerRegistry(dbPath, verbose);
-            return {
-                success: true,
-                backend,
-                dbPath,
-                schemaVersion: '3.0.0',
-                tablesCreated: [
-                    'memory_entries (pending)',
-                    'patterns (pending)',
-                    'pattern_history (pending)',
-                    'trajectories (pending)',
-                    'trajectory_steps (pending)',
-                    'migration_state (pending)',
-                    'sessions (pending)',
-                    'vector_indexes (pending)',
-                    'metadata (pending)'
-                ],
-                indexesCreated: [],
-                features: {
-                    vectorEmbeddings: true,
-                    patternLearning: true,
-                    temporalDecay: true,
-                    hnswIndexing: true,
-                    migrationTracking: true
-                },
-                controllers: controllerResult,
-            };
+        finally {
+            db.close();
         }
+        // Also create schema file for reference
+        const schemaPath = path.join(dbDir, 'schema.sql');
+        fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
+        // ADR-053: Activate ControllerRegistry so controllers (ReasoningBank,
+        // SkillLibrary, ExplainableRecall, etc.) are instantiated during init
+        const controllerResult = await activateControllerRegistry(dbPath, verbose);
+        return {
+            success: true,
+            backend,
+            dbPath,
+            schemaVersion: '3.0.0',
+            tablesCreated: [
+                'memory_entries',
+                'patterns',
+                'pattern_history',
+                'trajectories',
+                'trajectory_steps',
+                'migration_state',
+                'sessions',
+                'vector_indexes',
+                'metadata'
+            ],
+            indexesCreated: [
+                'idx_memory_namespace',
+                'idx_memory_key',
+                'idx_memory_type',
+                'idx_memory_status',
+                'idx_memory_created',
+                'idx_memory_accessed',
+                'idx_memory_owner',
+                'idx_patterns_type',
+                'idx_patterns_confidence',
+                'idx_patterns_status',
+                'idx_patterns_last_matched',
+                'idx_pattern_history_pattern',
+                'idx_steps_trajectory'
+            ],
+            features: {
+                vectorEmbeddings: true,
+                patternLearning: true,
+                temporalDecay: true,
+                hnswIndexing: true,
+                migrationTracking: true
+            },
+            controllers: controllerResult,
+        };
     }
     catch (error) {
         return {
@@ -1170,11 +1160,7 @@ export async function checkMemoryInitialization(dbPath) {
         return { initialized: false };
     }
     try {
-        // Try to load with sql.js
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(path_);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(path_);
         // Check for metadata table
         const tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
         const tableNames = tables[0]?.values?.map(v => v[0]) || [];
@@ -1215,10 +1201,7 @@ export async function checkMemoryInitialization(dbPath) {
 export async function applyTemporalDecay(dbPath) {
     const path_ = dbPath || memoryDbPath(process.cwd());
     try {
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(path_);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(path_);
         // Apply decay: confidence *= exp(-decay_rate * days_since_last_use)
         const now = Date.now();
         const decayQuery = `
@@ -1232,7 +1215,6 @@ export async function applyTemporalDecay(dbPath) {
     `;
         db.run(decayQuery, [now, now, now]);
         const changes = db.getRowsModified();
-        atomicWriteFileSync(path_, db.export());
         db.close();
         return {
             success: true,
@@ -1399,12 +1381,7 @@ export async function verifyMemoryInit(dbPath, options) {
     const { verbose = false } = options || {};
     const tests = [];
     try {
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fs = await import('fs');
-        // Load database
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(dbPath);
         // Test 1: Schema verification
         const schemaStart = Date.now();
         const tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
@@ -1532,9 +1509,10 @@ export async function verifyMemoryInit(dbPath, options) {
                 duration: Date.now() - indexStart
             });
         }
-        // Cleanup test entry
+        // Cleanup test entry — WAL persists this DELETE incrementally; no
+        // export+rewrite needed (the sql.js whole-file dump that lived here
+        // was the multi-writer clobber vector epic #1078 killed).
         db.run(`DELETE FROM memory_entries WHERE id = ?`, [testId]);
-        atomicWriteFileSync(dbPath, db.export());
         db.close();
         const passed = tests.filter(t => t.passed).length;
         const failed = tests.filter(t => !t.passed).length;
@@ -1561,8 +1539,8 @@ export async function verifyMemoryInit(dbPath, options) {
     }
 }
 /**
- * Store an entry directly using sql.js
- * This bypasses MCP and writes directly to the database
+ * Store an entry directly via node:sqlite.
+ * This bypasses MCP and writes directly to the database.
  */
 export async function storeEntry(options) {
     // Soft-redirect: `knowledge` is a deprecated alias for `learnings`. Writes
@@ -1579,9 +1557,9 @@ export async function storeEntry(options) {
     }
     // #981 — single-writer routing. When an external daemon is reachable AND
     // we're not the daemon ourselves AND no custom dbPath was supplied, route
-    // the write through the daemon's HTTP RPC so its in-memory sql.js handle
-    // stays authoritative. Any failure path falls through to the existing
-    // bridge / raw-sql.js logic below — byte-identical behaviour to today.
+    // the write through the daemon's HTTP RPC so its in-memory handle stays
+    // authoritative. Any failure path falls through to the existing bridge /
+    // direct-write logic below — byte-identical behaviour to today.
     if (!options.dbPath
         && process.env.MOFLO_IS_DAEMON !== '1'
         && process.env.MOFLO_DISABLE_DAEMON_ROUTING !== '1') {
@@ -1592,9 +1570,19 @@ export async function storeEntry(options) {
                 value: options.value,
                 tags: options.tags,
                 ttl: options.ttl,
+                metadata: options.metadata,
             });
             if (routed.routed && routed.ok) {
-                return { success: true, id: routed.id ?? '' };
+                // #1065 — surface the daemon's embedding metadata so the MCP
+                // memory_store handler reports `hasEmbedding: true` on
+                // daemon-routed writes (matching the bridge-direct shape).
+                return { success: true, id: routed.id ?? '', embedding: routed.embedding };
+            }
+            // #1101 — daemon validated and rejected (4xx). Bridge-direct would
+            // fail the same way; surface the daemon's error instead of silently
+            // falling back.
+            if (routed.routed && routed.ok === false) {
+                return { success: false, id: '', error: routed.error ?? 'Daemon rejected store request' };
             }
         }
         catch (err) {
@@ -1611,7 +1599,7 @@ export async function storeEntry(options) {
         if (bridgeResult)
             return bridgeResult;
     }
-    // Fallback: raw sql.js
+    // Fallback: direct node:sqlite write via the unified factory.
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
     const dbPath = customPath || memoryDbPath(process.cwd());
     try {
@@ -1620,10 +1608,7 @@ export async function storeEntry(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(dbPath);
         const id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
         const now = Date.now();
         // generateEmbedding() throws on embed failure; the outer try/catch returns
@@ -1654,7 +1639,7 @@ export async function storeEntry(options) {
                 embeddingModel = embResult.model;
             }
         }
-        // Idempotency guard. By the time we reach the raw-sql.js fallback, an
+        // Idempotency guard. By the time we reach the direct-write fallback, an
         // earlier write attempt — daemon route via `tryDaemonStore`, or bridge
         // via `bridgeStoreEntry` — may have already persisted this exact row to
         // disk. If a post-persist throw escaped the bridge's inner guards (#994,
@@ -1711,12 +1696,14 @@ export async function storeEntry(options) {
             embeddingDimensions,
             embeddingModel,
             tags.length > 0 ? JSON.stringify(tags) : null,
-            '{}',
+            serialiseMetadata(options.metadata),
             now,
             now,
             ttl ? now + (ttl * 1000) : null
         ]);
-        atomicWriteFileSync(dbPath, db.export());
+        // node:sqlite + WAL persisted that INSERT on commit — the sql.js
+        // whole-file `db.export()` + atomicWriteFileSync that lived here was
+        // the multi-writer clobber vector epic #1078 killed structurally.
         // Query exact stats while DB is still open. `missing` is the active-rows-
         // with-NULL-embedding count, surfaced via vector-stats.json so the
         // statusline can warn on coverage holes (#648 / #649).
@@ -1779,10 +1766,42 @@ export async function storeEntries(items, dbPath) {
     return out;
 }
 /**
- * Search entries using sql.js with vector similarity
- * Uses HNSW index for 150x faster search when available
+ * Search entries via node:sqlite with vector similarity.
+ * Uses HNSW index for 150x faster search when available.
  */
 export async function searchEntries(options) {
+    // #1058 — read-side routing preamble. When a daemon is reachable AND we're
+    // not the daemon ourselves AND no custom dbPath was supplied, route the
+    // search through the daemon's HTTP RPC so callers see its authoritative,
+    // up-to-the-write state. Without this, a non-daemon process queries its
+    // own bridge's sql.js snapshot loaded at process-start and never sees
+    // anything the daemon has written since (epic #1054 silent-drop).
+    if (!options.dbPath
+        && process.env.MOFLO_IS_DAEMON !== '1'
+        && process.env.MOFLO_DISABLE_DAEMON_ROUTING !== '1') {
+        try {
+            const routed = await tryDaemonSearch({
+                query: options.query,
+                namespace: options.namespace,
+                limit: options.limit,
+                threshold: options.threshold,
+            });
+            if (routed.routed && routed.data) {
+                return {
+                    success: true,
+                    results: routed.data.results,
+                    searchTime: routed.data.searchTime ?? 0,
+                };
+            }
+            // #1101 — daemon rejected query (4xx); propagate instead of falling back.
+            if (routed.routed && routed.error) {
+                return { success: false, results: [], searchTime: 0, error: routed.error };
+            }
+        }
+        catch (err) {
+            logRoutingFault(err);
+        }
+    }
     // ADR-053: Try AgentDB v3 bridge first
     const bridge = await getBridge();
     if (bridge) {
@@ -1790,7 +1809,7 @@ export async function searchEntries(options) {
         if (bridgeResult)
             return bridgeResult;
     }
-    // Fallback: raw sql.js
+    // Fallback: direct node:sqlite write via the unified factory.
     const { query, namespace = 'default', limit = 10, threshold = 0.3, dbPath: customPath } = options;
     const dbPath = customPath || memoryDbPath(process.cwd());
     const startTime = Date.now();
@@ -1814,11 +1833,8 @@ export async function searchEntries(options) {
                 searchTime: Date.now() - startTime
             };
         }
-        // Fall back to brute-force SQLite search
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
+        // Fall back to brute-force SQLite search via the unified factory.
+        const db = openDaemonDatabase(dbPath);
         // Get entries with embeddings
         const entries = db.exec(`
       SELECT id, key, namespace, content, metadata, embedding
@@ -1902,6 +1918,28 @@ function cosineSim(a, b) {
  * List all entries from the memory database
  */
 export async function listEntries(options) {
+    // #1058 — read-side routing preamble (mirrors searchEntries/getEntry).
+    if (!options.dbPath
+        && process.env.MOFLO_IS_DAEMON !== '1'
+        && process.env.MOFLO_DISABLE_DAEMON_ROUTING !== '1') {
+        try {
+            const routed = await tryDaemonList({
+                namespace: options.namespace,
+                limit: options.limit,
+                offset: options.offset,
+            });
+            if (routed.routed && routed.data) {
+                return { success: true, entries: routed.data.entries, total: routed.data.total };
+            }
+            // #1101 — daemon rejected list args (4xx); propagate.
+            if (routed.routed && routed.error) {
+                return { success: false, entries: [], total: 0, error: routed.error };
+            }
+        }
+        catch (err) {
+            logRoutingFault(err);
+        }
+    }
     // ADR-053: Try AgentDB v3 bridge first
     const bridge = await getBridge();
     if (bridge) {
@@ -1909,7 +1947,7 @@ export async function listEntries(options) {
         if (bridgeResult)
             return bridgeResult;
     }
-    // Fallback: raw sql.js
+    // Fallback: direct node:sqlite write via the unified factory.
     const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;
     const dbPath = customPath || memoryDbPath(process.cwd());
     try {
@@ -1918,10 +1956,7 @@ export async function listEntries(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(dbPath);
         // Get total count
         const countQuery = namespace
             ? `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = '${namespace.replace(/'/g, "''")}'`
@@ -1970,6 +2005,27 @@ export async function listEntries(options) {
  * Get a specific entry from the memory database
  */
 export async function getEntry(options) {
+    // #1058 — read-side routing preamble (mirrors searchEntries/listEntries).
+    if (!options.dbPath
+        && process.env.MOFLO_IS_DAEMON !== '1'
+        && process.env.MOFLO_DISABLE_DAEMON_ROUTING !== '1') {
+        try {
+            const routed = await tryDaemonGet({
+                namespace: options.namespace ?? 'default',
+                key: options.key,
+            });
+            if (routed.routed && routed.data) {
+                return { success: true, found: routed.data.found, entry: routed.data.entry };
+            }
+            // #1101 — daemon rejected get args (4xx); propagate.
+            if (routed.routed && routed.error) {
+                return { success: false, found: false, error: routed.error };
+            }
+        }
+        catch (err) {
+            logRoutingFault(err);
+        }
+    }
     // ADR-053: Try AgentDB v3 bridge first
     const bridge = await getBridge();
     if (bridge) {
@@ -1977,7 +2033,7 @@ export async function getEntry(options) {
         if (bridgeResult)
             return bridgeResult;
     }
-    // Fallback: raw sql.js
+    // Fallback: direct node:sqlite write via the unified factory.
     const { key, namespace = 'default', dbPath: customPath } = options;
     const dbPath = customPath || memoryDbPath(process.cwd());
     try {
@@ -1986,10 +2042,7 @@ export async function getEntry(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(dbPath);
         // Find entry by key
         const result = db.exec(`
       SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags, metadata
@@ -2004,13 +2057,15 @@ export async function getEntry(options) {
             return { success: true, found: false };
         }
         const [id, entryKey, ns, content, embedding, accessCount, createdAt, updatedAt, tagsJson, metadataJson] = result[0].values[0];
-        // Update access count
-        db.run(`
-      UPDATE memory_entries
-      SET access_count = access_count + 1, last_accessed_at = strftime('%s', 'now') * 1000
-      WHERE id = '${String(id).replace(/'/g, "''")}'
-    `);
-        atomicWriteFileSync(dbPath, db.export());
+        // #1058: previously this path issued `UPDATE memory_entries SET access_count = ...`
+        // followed by `atomicWriteFileSync(dbPath, db.export())` — a read that
+        // dumped the entire DB snapshot back to disk just to bump access_count.
+        // Any write by another process between this function's readFileSync and
+        // the writeback was clobbered (read-side writeback-clobber). Access_count
+        // is observability, not correctness — drop the writeback. The caller's
+        // return value reports the in-memory incremented count so existing
+        // surfaces aren't disturbed; persistence of the counter is deferred to a
+        // future controller-table refactor (out of scope).
         db.close();
         let tags = [];
         if (tagsJson) {
@@ -2053,7 +2108,7 @@ export async function getEntry(options) {
 export async function deleteEntry(options) {
     // #981 — single-writer routing for deletes. Same gates as storeEntry:
     // not the daemon, no custom dbPath, routing not opted out. Failure paths
-    // fall through to the existing bridge / raw-sql.js logic below.
+    // fall through to the existing bridge / direct-write logic below.
     if (!options.dbPath
         && process.env.MOFLO_IS_DAEMON !== '1'
         && process.env.MOFLO_DISABLE_DAEMON_ROUTING !== '1') {
@@ -2074,6 +2129,17 @@ export async function deleteEntry(options) {
                     remainingEntries: 0,
                 };
             }
+            // #1101 — daemon rejected delete args (4xx); propagate.
+            if (routed.routed && routed.ok === false) {
+                return {
+                    success: false,
+                    deleted: false,
+                    key: options.key,
+                    namespace: options.namespace ?? 'default',
+                    remainingEntries: 0,
+                    error: routed.error ?? 'Daemon rejected delete request',
+                };
+            }
         }
         catch (err) {
             logRoutingFault(err);
@@ -2086,7 +2152,7 @@ export async function deleteEntry(options) {
         if (bridgeResult)
             return bridgeResult;
     }
-    // Fallback: raw sql.js
+    // Fallback: direct node:sqlite write via the unified factory.
     const { key, namespace = 'default', dbPath: customPath } = options;
     const dbPath = customPath || memoryDbPath(process.cwd());
     try {
@@ -2102,10 +2168,7 @@ export async function deleteEntry(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(dbPath);
         // Check if entry exists first
         const checkResult = db.exec(`
       SELECT id FROM memory_entries
@@ -2135,7 +2198,7 @@ export async function deleteEntry(options) {
         // Get remaining count
         const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
         const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
-        atomicWriteFileSync(dbPath, db.export());
+        // WAL persisted the DELETE incrementally — no whole-file dump needed.
         db.close();
         return {
             success: true,
@@ -2166,10 +2229,7 @@ export async function getNamespaceCounts(dbPath) {
         if (!fs.existsSync(resolvedPath)) {
             return { namespaces: {}, total: 0 };
         }
-        const initSqlJs = (await mofloImport('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(resolvedPath);
-        const db = new SQL.Database(fileBuffer);
+        const db = openDaemonDatabase(resolvedPath);
         const result = db.exec("SELECT namespace, COUNT(*) as cnt FROM memory_entries WHERE status = 'active' GROUP BY namespace ORDER BY cnt DESC");
         db.close();
         const namespaces = {};