moflo 4.9.37 → 4.10.0

package/dist/src/cli/commands/doctor-checks-memory.js

@@ -8,24 +8,19 @@ import { existsSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 /** Skew (cached / live count delta) above which the cache is treated as stale. */
 const VECTOR_STATS_SKEW_WARN_THRESHOLD = 0.2;
 /**
- * Open `dbPath` via moflo's bundled sql.js and return the count of memory_entries
- * rows that have an embedding. Returns null if sql.js can't be loaded, the file
- * isn't a v3 schema, or the query fails — every error is treated as "unknown
- * truth", letting the caller fall back to the cached stats rather than masking
- * a healthy DB as broken.
+ * Open `dbPath` via the unified node:sqlite factory and return the count of
+ * memory_entries rows that have an embedding. Returns null on any error
+ * (corrupt DB, missing column, schema mismatch) — every error is treated as
+ * "unknown truth", letting the caller fall back to the cached stats rather
+ * than masking a healthy DB as broken.
  */
 async function countEmbeddedRowsFromDb(dbPath) {
     try {
-        const { mofloImport } = await import('../services/moflo-require.js');
-        const initSqlJs = (await mofloImport('sql.js'))?.default;
-        if (!initSqlJs)
-            return null;
-        const SQL = await initSqlJs();
-        const buffer = readFileSync(dbPath);
-        const db = new SQL.Database(buffer);
+        const db = openDaemonDatabase(dbPath);
         try {
             const res = db.exec("SELECT COUNT(*) FROM memory_entries WHERE embedding IS NOT NULL AND embedding != ''");
             const cell = res?.[0]?.values?.[0]?.[0];
@@ -137,21 +132,21 @@ export async function checkEmbeddings() {
             message: `Memory DB initialized (v${info.version}, vectors enabled)`,
         };
     }
-    catch (sqlJsError) {
-        // sql.js not available — fall back to file-size heuristic
-        const sqlDetail = errorDetail(sqlJsError);
+    catch (sqliteError) {
+        // node:sqlite open / introspection failed — fall back to file-size heuristic.
+        const sqlDetail = errorDetail(sqliteError);
         try {
             const stats = statSync(foundDbPath);
             const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
             return {
                 name: 'Embeddings',
                 status: 'warn',
-                message: `Memory DB exists (${sizeMB} MB) — cannot verify vectors (sql.js not available: ${sqlDetail})`,
-                fix: 'npm install sql.js && npx moflo embeddings init',
+                message: `Memory DB exists (${sizeMB} MB) — cannot verify vectors (DB unreadable: ${sqlDetail})`,
+                fix: 'npx moflo embeddings init',
             };
         }
         catch (statError) {
-            return { name: 'Embeddings', status: 'warn', message: `Unable to check: sql.js failed (${sqlDetail}), stat failed (${errorDetail(statError)})` };
+            return { name: 'Embeddings', status: 'warn', message: `Unable to check: DB read failed (${sqlDetail}), stat failed (${errorDetail(statError)})` };
         }
     }
 }

package/dist/src/cli/commands/doctor-checks-version-skew.js

@@ -0,0 +1,94 @@
+/**
+ * Daemon Version Skew doctor check (epic #1054.S5 / #1059).
+ *
+ * Surfaces the failure mode that silently masked the #1054 bug class for two
+ * version bumps: a long-lived daemon that survived `npm install moflo@<new>`
+ * keeps running pre-upgrade code while the on-disk package.json reads `<new>`.
+ *
+ * Distinct failure mode — NOT buried in "stale cache". Consumes the same
+ * signal the launcher acts on (`bin/session-start-launcher.mjs` section 3a-pre)
+ * via `getDaemonLockPayload` so the diagnosis and the auto-recycle path share
+ * one source of truth.
+ *
+ * @module cli/commands/doctor-checks-version-skew
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getDaemonLockPayload, readOwnMofloVersion } from '../services/daemon-lock.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+/**
+ * Resolve the installed package version from `node_modules/moflo/package.json`.
+ * Falls back to the daemon's own version (same package on consumers; same
+ * dogfood layout in this repo).
+ */
+function readInstalledVersion(cwd) {
+    const pkgPath = join(cwd, 'node_modules', 'moflo', 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+            if (typeof pkg.version === 'string')
+                return pkg.version;
+        }
+        catch {
+            // unreadable / malformed — fall through
+        }
+    }
+    // Dogfood path (this repo): no `node_modules/moflo`; read the root package
+    // via the same walker the daemon uses.
+    return readOwnMofloVersion() ?? null;
+}
+/**
+ * Distinct doctor entry — fails when the running daemon's `version` (recorded
+ * in `.moflo/daemon.lock` by S2) does not match the installed package version.
+ *
+ * Pre-#1054 daemons have no `version` in their lock — treated as a mismatch
+ * because by construction they were launched before version publishing
+ * existed.
+ *
+ * No daemon running → pass with a neutral message (the daemon-status check
+ * already owns the "not running" diagnosis).
+ */
+export async function checkDaemonVersionSkew(cwd = process.cwd()) {
+    const name = 'Daemon Version Skew';
+    try {
+        const installed = readInstalledVersion(cwd);
+        if (!installed) {
+            return {
+                name,
+                status: 'warn',
+                message: 'Cannot resolve installed moflo version (no node_modules/moflo/package.json)',
+            };
+        }
+        const payload = getDaemonLockPayload(cwd);
+        if (!payload) {
+            return {
+                name,
+                status: 'pass',
+                message: `No daemon running — installed v${installed}`,
+            };
+        }
+        const observed = payload.version ?? '<pre-1054 / unknown>';
+        if (payload.version === installed) {
+            return {
+                name,
+                status: 'pass',
+                message: `Daemon v${observed} matches installed v${installed} (PID ${payload.pid})`,
+            };
+        }
+        return {
+            name,
+            status: 'fail',
+            message: `Daemon (PID ${payload.pid}) running v${observed} but installed package is v${installed}. ` +
+                `Stale pre-upgrade daemon — every write it makes is against pre-upgrade code paths (#1054 bug class).`,
+            fix: 'npx moflo daemon stop && npx moflo daemon start',
+        };
+    }
+    catch (e) {
+        return {
+            name,
+            status: 'warn',
+            message: `Unable to check version skew: ${errorDetail(e, { firstLineOnly: true })}`,
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-version-skew.js.map

package/dist/src/cli/commands/doctor-checks-writers-audit.js

@@ -0,0 +1,170 @@
+/**
+ * Writers Audit runtime doctor check (epic #1054.S5 / #1059).
+ *
+ * Runtime sibling of S1's static lint (`tests/system/moflo-db-writer-audit.test.ts`).
+ * Enumerates running node processes whose command line invokes one of the
+ * known cross-process writers (build-embeddings, migrations) and fails if any
+ * are alive while the daemon owns the lock.
+ *
+ * Why not lsof / handle.exe?
+ *   - `lsof` not installed on every Linux distro and not on Windows.
+ *   - `handle.exe` (Sysinternals) requires manual install.
+ *   - `openfiles.exe` is disabled by default on Windows and requires a reboot to
+ *     enable.
+ *
+ * Command-line signature scan is cross-platform, dependency-free, and matches
+ * the writers we actually care about — S3 ported them all to the daemon-offline
+ * pattern, so any of them being alive concurrently with the daemon is a
+ * regression of S3's wrapper logic.
+ *
+ * @module cli/commands/doctor-checks-writers-audit
+ */
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getDaemonLockHolder } from '../services/daemon-lock.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+const SCAN_TIMEOUT_MS_WIN = 10_000;
+const SCAN_TIMEOUT_MS_POSIX = 5_000;
+const CMDLINE_CAPTURE_LEN = 300;
+/**
+ * Command-line fragments that identify a CROSS-PROCESS moflo.db writer.
+ * These should never run while the daemon owns the lock (S3 wraps every
+ * invocation in an explicit daemon-stop). Indexer scripts (index-guidance,
+ * index-tests, etc.) are daemon-spawned children — they appear in
+ * `background-pids.json` and are filtered out below.
+ */
+const FOREIGN_WRITER_PATTERNS = [
+    /build-embeddings\.mjs/i,
+    /bin[\\\/]migrations[\\\/][^\s"']+\.mjs/i,
+    /lib[\\\/]db-repair\.mjs/i,
+];
+function readTrackedBackgroundPids(cwd) {
+    const result = new Set();
+    const registryFile = join(cwd, '.moflo', 'background-pids.json');
+    try {
+        if (!existsSync(registryFile))
+            return result;
+        const entries = JSON.parse(readFileSync(registryFile, 'utf-8'));
+        if (!Array.isArray(entries))
+            return result;
+        for (const entry of entries) {
+            if (entry && typeof entry.pid === 'number' && entry.pid > 0) {
+                result.add(entry.pid);
+            }
+        }
+    }
+    catch { /* unreadable — treat as empty */ }
+    return result;
+}
+function enumerateNodeProcesses() {
+    try {
+        if (process.platform === 'win32') {
+            const csv = execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"Name=\'node.exe\'\\" | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"', { encoding: 'utf-8', timeout: SCAN_TIMEOUT_MS_WIN, windowsHide: true });
+            const out = [];
+            for (const line of csv.split(/\r?\n/)) {
+                const m = line.match(/^"(\d+)","?(.*?)"?$/);
+                if (!m)
+                    continue;
+                const pid = parseInt(m[1], 10);
+                if (!Number.isFinite(pid) || pid <= 0)
+                    continue;
+                out.push({ pid, cmdline: m[2].replace(/""/g, '"').slice(0, CMDLINE_CAPTURE_LEN) });
+            }
+            return out;
+        }
+        // POSIX
+        const ps = execSync('ps -ww -eo pid,command', { encoding: 'utf-8', timeout: SCAN_TIMEOUT_MS_POSIX });
+        const out = [];
+        for (const line of ps.split(/\r?\n/)) {
+            const m = line.trim().match(/^(\d+)\s+(.*)$/);
+            if (!m)
+                continue;
+            const cmd = m[2];
+            if (!/\bnode\b/.test(cmd))
+                continue;
+            const pid = parseInt(m[1], 10);
+            if (!Number.isFinite(pid) || pid <= 0)
+                continue;
+            out.push({ pid, cmdline: cmd.slice(0, CMDLINE_CAPTURE_LEN) });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function formatCmdline(raw, max = 80) {
+    const cleaned = raw.replace(/^"?[^"\s]*node(?:\.exe)?"?\s+/i, '').trim();
+    return cleaned.length > max ? cleaned.slice(0, max - 1) + '…' : cleaned;
+}
+export function findForeignWriters(procs, daemonPid, trackedPids, selfPid) {
+    const out = [];
+    for (const p of procs) {
+        if (p.pid === selfPid)
+            continue;
+        if (p.pid === daemonPid)
+            continue;
+        if (trackedPids.has(p.pid))
+            continue;
+        for (const re of FOREIGN_WRITER_PATTERNS) {
+            const m = p.cmdline.match(re);
+            if (m) {
+                out.push({ ...p, matchedPattern: m[0] });
+                break;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Pass: daemon down (single-writer invariant has nothing to enforce) OR no
+ * foreign writers detected.
+ *
+ * Fail: daemon owns the lock AND a non-daemon, non-tracked node process is
+ * running a known cross-process writer. Lists every offender so the user can
+ * SIGKILL them by PID.
+ */
+export async function checkWritersAudit(cwd = process.cwd()) {
+    const name = 'Writers Audit';
+    try {
+        const daemonPid = getDaemonLockHolder(cwd);
+        if (daemonPid === null) {
+            return {
+                name,
+                status: 'pass',
+                message: 'Daemon not running — single-writer invariant trivially satisfied',
+            };
+        }
+        const procs = enumerateNodeProcesses();
+        const trackedPids = readTrackedBackgroundPids(cwd);
+        const foreign = findForeignWriters(procs, daemonPid, trackedPids, process.pid);
+        if (foreign.length === 0) {
+            return {
+                name,
+                status: 'pass',
+                message: `Daemon PID ${daemonPid} is sole writer; no foreign writers detected`,
+            };
+        }
+        const detail = foreign
+            .map((p) => `pid=${p.pid} (${p.matchedPattern}): ${formatCmdline(p.cmdline)}`)
+            .join(' | ');
+        return {
+            name,
+            status: 'fail',
+            message: `${foreign.length} non-daemon writer(s) running concurrently with daemon (PID ${daemonPid}): ${detail}. ` +
+                `Each will clobber the daemon's sql.js snapshot on flush — #1054 bug class.`,
+            fix: process.platform === 'win32'
+                ? `taskkill /F /PID ${foreign.map((p) => p.pid).join(' /PID ')}`
+                : `kill ${foreign.map((p) => p.pid).join(' ')}`,
+        };
+    }
+    catch (e) {
+        return {
+            name,
+            status: 'warn',
+            message: `Unable to audit writers: ${errorDetail(e, { firstLineOnly: true })}`,
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-writers-audit.js.map

package/dist/src/cli/commands/doctor-embedding-hygiene.js

@@ -24,8 +24,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { existsSync } from 'fs';
 import { CANONICAL_EMBEDDING_MODEL } from '../embeddings/migration/types.js';
-import { mofloImport } from '../services/moflo-require.js';
 import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 /**
  * Known neural-model labels that all share the all-MiniLM-L6-v2 384-dim
  * vector space. The Story-2 migration retags any of these to the
@@ -59,7 +59,7 @@ export async function checkEmbeddingHygiene() {
         return {
             name: 'Embedding hygiene',
             status: 'pass',
-            message: 'Cannot inspect memory DB (sql.js not available)',
+            message: 'Cannot inspect memory DB (open failed)',
         };
     }
     if (groups.length === 0) {
@@ -127,21 +127,9 @@ function resolveMemoryDb() {
     return memoryDbCandidatePaths(process.cwd()).find((p) => existsSync(p)) ?? null;
 }
 async function loadModelGroups(dbPath) {
-    const fs = await import('fs');
-    let initSqlJs;
-    try {
-        initSqlJs = (await mofloImport('sql.js'))?.default;
-    }
-    catch {
-        return null;
-    }
-    if (!initSqlJs)
-        return null;
     let db;
     try {
-        const SQL = await initSqlJs();
-        const buffer = fs.readFileSync(dbPath);
-        db = new SQL.Database(buffer);
+        db = openDaemonDatabase(dbPath);
     }
     catch {
         return null;

package/dist/src/cli/commands/doctor-fixes.js

@@ -169,6 +169,36 @@ export async function autoFixCheck(check) {
             catch { /* best effort */ }
             return runFixCommand('npx moflo daemon start');
         },
+        // Epic #1054.S5 / #1059 — SIGTERM the stale daemon and let the launcher's
+        // existing respawn path (mirrored as `npx moflo daemon start`) pick up the
+        // installed-version code. Mirrors `recycleDaemon` in
+        // bin/session-start-launcher.mjs so the auto-fix matches the launcher's
+        // behavior exactly.
+        'Daemon Version Skew': async () => {
+            const cwd = process.cwd();
+            const { getDaemonLockPayload } = await import('../services/daemon-lock.js');
+            const payload = getDaemonLockPayload(cwd);
+            if (payload?.pid && payload.pid > 0) {
+                try {
+                    process.kill(payload.pid, 'SIGTERM');
+                }
+                catch { /* already dead */ }
+            }
+            const lockFile = join(cwd, '.moflo', 'daemon.lock');
+            try {
+                if (existsSync(lockFile))
+                    unlinkSync(lockFile);
+            }
+            catch { /* ok */ }
+            return runFixCommand('npx moflo daemon start');
+        },
+        'Embedding Coverage Truth': async () => {
+            // Same as the existing Embeddings fix — rebuild the cache by re-running
+            // the embeddings pipeline. Routes through `npx moflo` so the consumer
+            // CLI resolution stays consistent across platforms (see
+            // feedback_cross_platform_mandatory).
+            return runFixCommand('npx moflo embeddings init --force');
+        },
         'MCP Servers': async () => {
             return runFixCommand('claude mcp add moflo -- npx -y moflo mcp start');
         },

package/dist/src/cli/commands/doctor-registry.js

@@ -6,6 +6,9 @@
  */
 import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkHookBlockDrift, checkMofloDbBridge, } from './doctor-checks-deep.js';
 import { checkEmbeddingHygiene } from './doctor-embedding-hygiene.js';
+import { checkDaemonVersionSkew } from './doctor-checks-version-skew.js';
+import { checkEmbeddingCoverageTruth } from './doctor-checks-coverage-truth.js';
+import { checkWritersAudit } from './doctor-checks-writers-audit.js';
 import { checkSwarmFunctional, checkHiveMindFunctional, } from './doctor-checks-swarm.js';
 import { checkMemoryAccessFunctional } from './doctor-checks-memory-access.js';
 import { checkBuildTools, checkClaudeCode, checkDiskSpace, checkGit, checkGitRepo, checkNodeVersion, checkNpmVersion, } from './doctor-checks-runtime.js';
@@ -33,10 +36,13 @@ export const allChecks = [
     checkMofloYamlCompliance,
     checkStatusLine,
     checkDaemonStatus,
+    checkDaemonVersionSkew,
     checkDaemonWriteRouting,
+    checkWritersAudit,
     checkMemoryDatabase,
     checkEmbeddings,
     checkEmbeddingHygiene,
+    checkEmbeddingCoverageTruth,
     checkTestDirs,
     checkMcpServers,
     checkDiskSpace,
@@ -77,11 +83,19 @@ export const componentMap = {
     'statusline': checkStatusLine,
     'status-line': checkStatusLine,
     'daemon': checkDaemonStatus,
+    'daemon-version-skew': checkDaemonVersionSkew,
+    'version-skew': checkDaemonVersionSkew,
+    'skew': checkDaemonVersionSkew,
     'daemon-write-routing': checkDaemonWriteRouting,
     'write-routing': checkDaemonWriteRouting,
+    'writers-audit': checkWritersAudit,
+    'writers': checkWritersAudit,
     'memory': checkMemoryDatabase,
     'embeddings': checkEmbeddings,
     'embedding-hygiene': checkEmbeddingHygiene,
+    'embedding-coverage': checkEmbeddingCoverageTruth,
+    'coverage': checkEmbeddingCoverageTruth,
+    'coverage-truth': checkEmbeddingCoverageTruth,
     'hygiene': checkEmbeddingHygiene,
     'git': checkGit,
     'mcp': checkMcpServers,

package/dist/src/cli/commands/doctor.js

@@ -40,7 +40,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, embeddings, git, mcp, claude, disk, typescript, semantic, intelligence, swarm, hive-mind)',
+            description: 'Check specific component (version, version-skew, node, npm, config, daemon, writers-audit, memory, embeddings, coverage-truth, git, mcp, claude, disk, typescript, semantic, intelligence, swarm, hive-mind)',
             type: 'string',
         },
         {

package/dist/src/cli/commands/embeddings.js

@@ -13,10 +13,10 @@
  * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
-import { mofloImport } from '../services/moflo-require.js';
 import { runEmbeddingsMigrationIfNeeded } from '../services/embeddings-migration.js';
 import { memoryDbPath, MEMORY_DB_FILE, MOFLO_DIR } from '../services/moflo-paths.js';
 import * as embeddings from '../embeddings/index.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 const DEFAULT_DB_PATH_FLAG = `${MOFLO_DIR}/${MEMORY_DB_FILE}`;
 // Generate subcommand - REAL implementation
@@ -90,7 +90,7 @@ const generateCommand = {
         }
     },
 };
-// Search subcommand - REAL implementation using sql.js
+// Search subcommand - REAL implementation using node:sqlite via openDaemonDatabase
 const searchCommand = {
     name: 'search',
     description: 'Semantic similarity search',
@@ -131,11 +131,8 @@ const searchCommand = {
                 output.printInfo('Run: claude-flow memory init');
                 return { success: false, exitCode: 1 };
             }
-            // Load sql.js
-            const initSqlJs = (await mofloImport('sql.js')).default;
-            const SQL = await initSqlJs();
-            const fileBuffer = fs.readFileSync(fullDbPath);
-            const db = new SQL.Database(fileBuffer);
+            // node:sqlite via the unified factory (Phase 5 / #1084).
+            const db = openDaemonDatabase(fullDbPath);
             const startTime = Date.now();
             // Generate embedding for query
             const { generateEmbedding } = await import('../memory/memory-initializer.js');
@@ -343,7 +340,7 @@ const compareCommand = {
         }
     },
 };
-// Collections subcommand - REAL implementation using sql.js
+// Collections subcommand - REAL implementation using node:sqlite via openDaemonDatabase
 const collectionsCommand = {
     name: 'collections',
     description: 'Manage embedding collections (namespaces)',
@@ -374,11 +371,8 @@ const collectionsCommand = {
                 output.writeln(output.dim('No collections yet - initialize memory first'));
                 return { success: true, data: [] };
             }
-            // Load sql.js and query real data
-            const initSqlJs = (await mofloImport('sql.js')).default;
-            const SQL = await initSqlJs();
-            const fileBuffer = fs.readFileSync(fullDbPath);
-            const db = new SQL.Database(fileBuffer);
+            // node:sqlite via the unified factory (Phase 5 / #1084).
+            const db = openDaemonDatabase(fullDbPath);
             // Get collection stats from database
             const statsQuery = db.exec(`
         SELECT
@@ -1159,17 +1153,18 @@ const cacheCommand = {
                 else {
                     sqliteSize = `${sizeBytes} B`;
                 }
-                // Try to count real entries via sql.js
+                // Try to count real entries via node:sqlite
                 try {
-                    const initSqlJs = (await mofloImport('sql.js')).default;
-                    const SQL = await initSqlJs();
-                    const fileBuffer = fs.readFileSync(resolvedDbPath);
-                    const db = new SQL.Database(fileBuffer);
-                    const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
-                    if (result.length > 0 && result[0].values.length > 0) {
-                        sqliteEntries = result[0].values[0][0];
+                    const db = openDaemonDatabase(resolvedDbPath);
+                    try {
+                        const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
+                        if (result.length > 0 && result[0].values.length > 0) {
+                            sqliteEntries = result[0].values[0][0];
+                        }
+                    }
+                    finally {
+                        db.close();
                     }
-                    db.close();
                 }
                 catch {
                     // Estimate entries from file size (~1600 bytes per entry for 384-dim embeddings)

package/dist/src/cli/commands/memory.js

@@ -7,8 +7,7 @@ import * as pathModule from 'path';
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { mofloImport } from '../services/moflo-require.js';
-import { atomicWriteFileSync } from '../services/atomic-file-write.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 // Memory backends
 const BACKENDS = [
@@ -1265,23 +1264,10 @@ const initMemoryCommand = {
 const DB_FILENAME = 'memory.db';
 const SWARM_DIR = '.swarm';
 async function openDb(cwd) {
-    const fs = await import('fs');
     const path = await import('path');
-    const initSqlJs = (await mofloImport('sql.js')).default;
-    const SQL = await initSqlJs();
     const dbPath = path.join(cwd, SWARM_DIR, DB_FILENAME);
-    const dir = path.dirname(dbPath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    let db;
-    if (fs.existsSync(dbPath)) {
-        const buffer = fs.readFileSync(dbPath);
-        db = new SQL.Database(buffer);
-    }
-    else {
-        db = new SQL.Database();
-    }
+    // openDaemonDatabase ensures the parent directory exists and applies WAL.
+    const db = openDaemonDatabase(dbPath);
     // Ensure table exists
     db.run(`
     CREATE TABLE IF NOT EXISTS memory_entries (
@@ -1307,10 +1293,14 @@ async function openDb(cwd) {
   `);
     db.run(`CREATE INDEX IF NOT EXISTS idx_memory_key_ns ON memory_entries(key, namespace)`);
     db.run(`CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace)`);
-    return { db, dbPath, SQL };
+    return { db, dbPath };
 }
-function saveAndCloseDb(db, dbPath) {
-    atomicWriteFileSync(dbPath, db.export());
+/**
+ * Close the DB handle. node:sqlite + WAL has already persisted every prior
+ * `db.run` incrementally — the explicit atomicWriteFileSync sql.js used to
+ * need is gone (Phase 5 / #1084).
+ */
+function saveAndCloseDb(db, _dbPath) {
     db.close();
 }
 function batchGenerateId() {
@@ -1937,9 +1927,9 @@ const rebuildIndexCommand = {
                 }
                 failed++;
             }
-            if ((i + 1) % BATCH_SIZE === 0) {
-                atomicWriteFileSync(dbPath, db.export());
-            }
+            // node:sqlite + WAL persists each db.run incrementally — the
+            // periodic batch flush sql.js needed here was the export-+-rewrite
+            // pattern Phase 5 (#1084) killed. No flush needed.
         }
         const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
         // Final stats