moflo 4.9.37 → 4.10.0

package/dist/src/cli/memory/rvf-migration.js

@@ -1,12 +1,13 @@
 /**
  * RVF Migration Utility — bidirectional migration between RVF and legacy
- * formats (JSON files, sql.js / better-sqlite3 databases).
+ * formats (JSON files, node:sqlite databases).
  * @module moflo/cli/memory/rvf-migration
  */
 import { readFile, writeFile, rename, unlink, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { RvfBackend } from './rvf-backend.js';
+import { openDaemonDatabase } from './daemon-backend.js';
 import { generateMemoryId } from './types.js';
 // -- Internal helpers -------------------------------------------------------
 function fillDefaults(raw) {
@@ -106,18 +107,31 @@ function normalizeSqliteRow(row) {
     }
     return out;
 }
+/**
+ * Read `memory_entries` rows out of a legacy SQLite file via the unified
+ * `openDaemonDatabase` factory. node:sqlite's built-in WAL handling means
+ * the read is non-destructive to any concurrent writer.
+ */
 async function readSqliteRows(dbPath) {
-    // Use sql.js (WASM) for SQLite reading
+    const db = openDaemonDatabase(dbPath);
     try {
-        const { initSqlJsForNode } = await import('./sqljs-backend.js');
-        const SQL = await initSqlJsForNode();
-        const fs = await import('node:fs');
-        const buf = fs.readFileSync(dbPath);
-        const db = new SQL.Database(buf);
-        return { exec: (sql) => db.exec(sql), close: () => db.close() };
+        const result = db.exec(`SELECT id, key, namespace, content, type, embedding, embedding_model,
+              embedding_dimensions, tags, metadata, owner_id, created_at,
+              updated_at, expires_at, last_accessed_at, access_count, status
+       FROM memory_entries`);
+        if (!result[0]?.values?.length)
+            return [];
+        const columns = result[0].columns;
+        return result[0].values.map((row) => {
+            const obj = {};
+            for (let i = 0; i < columns.length; i++) {
+                obj[columns[i]] = row[i];
+            }
+            return obj;
+        });
     }
-    catch {
-        throw new Error('Cannot read SQLite: install sql.js');
+    finally {
+        db.close();
     }
 }
 // -- Batch migration helper -------------------------------------------------
@@ -175,7 +189,7 @@ export class RvfMigrator {
             console.log(`[RvfMigrator] Migrated ${migrated} entries from JSON to RVF`);
         return mkResult(errors.length === 0, migrated, 'json', 'rvf', start, errors);
     }
-    /** Migrate a SQLite (better-sqlite3 / sql.js) database to RVF. */
+    /** Migrate a SQLite (node:sqlite) database to RVF. */
     static async fromSqlite(dbPath, rvfPath, options = {}) {
         const start = Date.now();
         let rows;

package/dist/src/cli/memory/sqlite-backend.js

@@ -0,0 +1,573 @@
+/**
+ * SqliteBackend — native node:sqlite backend for moflo.db
+ *
+ * Drop-in replacement for {@link SqlJsBackend} (same IMemoryBackend surface,
+ * same schema, same event emissions) backed by the Node 22+ built-in
+ * `node:sqlite` engine instead of WASM. Phase 4 (#1083) made this the
+ * default; Phase 5 (#1084) deletes the sql.js backend + npm dep.
+ *
+ * Why this exists: epic #1078 / Phase 0 spike (#1079, PR #1085) confirmed
+ * `node:sqlite` parity against shipped sql.js DBs. The structural sql.js
+ * failure mode is whole-file snapshots: each process holds its own copy and
+ * the last flusher wipes the other's writes. `node:sqlite` writes through
+ * the OS file handle and uses WAL for multi-process serialization, which
+ * removes that failure mode entirely.
+ *
+ * @module v3/memory/sqlite-backend
+ */
+// MUST come before `import 'node:sqlite'` below — see suppress-sqlite-warning
+// header for rationale (#1098).
+import './suppress-sqlite-warning.js';
+import { EventEmitter } from 'node:events';
+import { DatabaseSync } from 'node:sqlite';
+import { cosineSimilarity } from './hnsw-lite.js';
+const DEFAULT_CONFIG = {
+    databasePath: ':memory:',
+    optimize: true,
+    defaultNamespace: 'default',
+    maxEntries: 1000000,
+    verbose: false,
+    autoPersistInterval: 0,
+};
+export class SqliteBackend extends EventEmitter {
+    config;
+    db = null;
+    initialized = false;
+    stmts = {};
+    cachedPageSize = 0;
+    stats = {
+        queryCount: 0,
+        totalQueryTime: 0,
+        writeCount: 0,
+        totalWriteTime: 0,
+    };
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        const db = new DatabaseSync(this.config.databasePath);
+        try {
+            if (this.config.databasePath !== ':memory:') {
+                // WAL is required for the multi-process serialization invariant proven
+                // in the Phase 0 spike. The spike verified the .db-wal/.db-shm sidecars
+                // appear on first write.
+                //
+                // busy_timeout BEFORE journal_mode = WAL: the WAL pragma briefly takes
+                // an EXCLUSIVE lock, and concurrent openers otherwise hit "database is
+                // locked" with no retry budget (#1097).
+                // 15000ms matches daemon-backend.ts (#1098 — the harness's first-pass
+                // indexer can hold a write lock for 5–8s after npm install).
+                db.exec('PRAGMA busy_timeout = 15000');
+                db.exec('PRAGMA journal_mode = WAL');
+                db.exec('PRAGMA synchronous = NORMAL');
+            }
+            this.db = db;
+            this.createSchema();
+            this.prepareCachedStatements();
+            this.cachedPageSize = this.readPageSize();
+        }
+        catch (err) {
+            // Don't leak the handle if any setup step threw — a subsequent
+            // initialize() retry would otherwise orphan it.
+            try {
+                db.close();
+            }
+            catch { /* already closed */ }
+            this.db = null;
+            this.stmts = {};
+            throw err;
+        }
+        this.initialized = true;
+        this.emit('initialized');
+        if (this.config.verbose) {
+            console.log(`[SqliteBackend] Ready (${this.config.databasePath})`);
+        }
+    }
+    readPageSize() {
+        if (!this.db)
+            return 0;
+        try {
+            const row = this.db.prepare('PRAGMA page_size').get();
+            return Number(row?.page_size ?? 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+    async shutdown() {
+        if (!this.initialized || !this.db)
+            return;
+        // Finalize cached statements before closing — node:sqlite requires every
+        // prepared statement to be released before db.close().
+        this.stmts = {};
+        this.db.close();
+        this.db = null;
+        this.initialized = false;
+        this.emit('shutdown');
+    }
+    createSchema() {
+        if (!this.db)
+            return;
+        // Mirrors SqlJsBackend.createSchema exactly. `IF NOT EXISTS` is a no-op
+        // when a pre-existing DB (e.g. one created by MEMORY_SCHEMA_V3) already
+        // has the table — the schema discrepancy noted in epic #1078 Phase 0 is
+        // tolerated here for drop-in parity.
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        key TEXT NOT NULL,
+        content TEXT NOT NULL,
+        embedding BLOB,
+        type TEXT NOT NULL,
+        namespace TEXT NOT NULL,
+        tags TEXT NOT NULL,
+        metadata TEXT NOT NULL,
+        owner_id TEXT,
+        access_level TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        expires_at INTEGER,
+        version INTEGER NOT NULL DEFAULT 1,
+        "references" TEXT NOT NULL,
+        access_count INTEGER NOT NULL DEFAULT 0,
+        last_accessed_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_namespace ON memory_entries(namespace);
+      CREATE INDEX IF NOT EXISTS idx_key ON memory_entries(key);
+      CREATE INDEX IF NOT EXISTS idx_type ON memory_entries(type);
+      CREATE INDEX IF NOT EXISTS idx_created_at ON memory_entries(created_at);
+      CREATE INDEX IF NOT EXISTS idx_expires_at ON memory_entries(expires_at);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_namespace_key ON memory_entries(namespace, key);
+    `);
+    }
+    prepareCachedStatements() {
+        if (!this.db)
+            return;
+        this.stmts.store = this.db.prepare(`
+      INSERT OR REPLACE INTO memory_entries (
+        id, key, content, embedding, type, namespace, tags, metadata,
+        owner_id, access_level, created_at, updated_at, expires_at,
+        version, "references", access_count, last_accessed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        this.stmts.getById = this.db.prepare('SELECT * FROM memory_entries WHERE id = ?');
+        this.stmts.getByKey = this.db.prepare('SELECT * FROM memory_entries WHERE namespace = ? AND key = ?');
+        this.stmts.deleteById = this.db.prepare('DELETE FROM memory_entries WHERE id = ?');
+        this.stmts.updateAccess = this.db.prepare('UPDATE memory_entries SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?');
+        this.stmts.countAll = this.db.prepare('SELECT COUNT(*) AS c FROM memory_entries');
+        this.stmts.countByNamespace = this.db.prepare('SELECT COUNT(*) AS c FROM memory_entries WHERE namespace = ?');
+        this.stmts.countByType = this.db.prepare('SELECT COUNT(*) AS c FROM memory_entries WHERE type = ?');
+        this.stmts.listNamespaces = this.db.prepare('SELECT DISTINCT namespace FROM memory_entries');
+        this.stmts.clearNamespace = this.db.prepare('SELECT COUNT(*) AS c FROM memory_entries WHERE namespace = ?');
+        this.stmts.deleteByNamespace = this.db.prepare('DELETE FROM memory_entries WHERE namespace = ?');
+    }
+    async store(entry) {
+        this.ensureInitialized();
+        const t0 = performance.now();
+        // Copy into a fresh Buffer rather than reusing entry.embedding.buffer —
+        // the underlying ArrayBufferLike may be a SharedArrayBuffer (typing
+        // mismatch with node:sqlite's Buffer expectation) and downstream code
+        // shouldn't be coupled to whatever allocation backed the input.
+        let embeddingBuf = null;
+        if (entry.embedding) {
+            embeddingBuf = Buffer.alloc(entry.embedding.byteLength);
+            embeddingBuf.set(new Uint8Array(entry.embedding.buffer.slice(entry.embedding.byteOffset, entry.embedding.byteOffset + entry.embedding.byteLength)));
+        }
+        this.stmts.store.run(entry.id, entry.key, entry.content, embeddingBuf, entry.type, entry.namespace, JSON.stringify(entry.tags), JSON.stringify(entry.metadata), entry.ownerId ?? null, entry.accessLevel, entry.createdAt, entry.updatedAt, entry.expiresAt ?? null, entry.version, JSON.stringify(entry.references), entry.accessCount, entry.lastAccessedAt);
+        const duration = performance.now() - t0;
+        this.stats.writeCount++;
+        this.stats.totalWriteTime += duration;
+        this.emit('entry:stored', { entry, duration });
+    }
+    async get(id) {
+        this.ensureInitialized();
+        const t0 = performance.now();
+        const row = this.stmts.getById.get(id);
+        const duration = performance.now() - t0;
+        this.stats.queryCount++;
+        this.stats.totalQueryTime += duration;
+        if (!row)
+            return null;
+        const entry = this.rowToEntry(row);
+        this.updateAccessTracking(id);
+        this.emit('entry:retrieved', { id, duration });
+        return entry;
+    }
+    async getByKey(namespace, key) {
+        this.ensureInitialized();
+        const t0 = performance.now();
+        const row = this.stmts.getByKey.get(namespace, key);
+        const duration = performance.now() - t0;
+        this.stats.queryCount++;
+        this.stats.totalQueryTime += duration;
+        if (!row)
+            return null;
+        const entry = this.rowToEntry(row);
+        this.updateAccessTracking(entry.id);
+        this.emit('entry:retrieved', { namespace, key, duration });
+        return entry;
+    }
+    async update(id, updateData) {
+        this.ensureInitialized();
+        const t0 = performance.now();
+        const existing = await this.get(id);
+        if (!existing)
+            return null;
+        const updated = {
+            ...existing,
+            ...updateData,
+            updatedAt: Date.now(),
+            version: existing.version + 1,
+        };
+        await this.store(updated);
+        const duration = performance.now() - t0;
+        this.emit('entry:updated', { id, update: updateData, duration });
+        return updated;
+    }
+    async delete(id) {
+        this.ensureInitialized();
+        const t0 = performance.now();
+        this.stmts.deleteById.run(id);
+        const duration = performance.now() - t0;
+        this.stats.writeCount++;
+        this.stats.totalWriteTime += duration;
+        this.emit('entry:deleted', { id, duration });
+        return true;
+    }
+    async query(query) {
+        this.ensureInitialized();
+        const t0 = performance.now();
+        let sql = 'SELECT * FROM memory_entries WHERE 1=1';
+        const params = [];
+        if (query.namespace) {
+            sql += ' AND namespace = ?';
+            params.push(query.namespace);
+        }
+        if (query.memoryType) {
+            sql += ' AND type = ?';
+            params.push(query.memoryType);
+        }
+        if (query.ownerId) {
+            sql += ' AND owner_id = ?';
+            params.push(query.ownerId);
+        }
+        if (query.accessLevel) {
+            sql += ' AND access_level = ?';
+            params.push(query.accessLevel);
+        }
+        if (query.key) {
+            sql += ' AND key = ?';
+            params.push(query.key);
+        }
+        else if (query.keyPrefix) {
+            sql += ' AND key LIKE ?';
+            params.push(query.keyPrefix + '%');
+        }
+        if (query.createdAfter !== undefined) {
+            sql += ' AND created_at >= ?';
+            params.push(query.createdAfter);
+        }
+        if (query.createdBefore !== undefined) {
+            sql += ' AND created_at <= ?';
+            params.push(query.createdBefore);
+        }
+        if (query.updatedAfter !== undefined) {
+            sql += ' AND updated_at >= ?';
+            params.push(query.updatedAfter);
+        }
+        if (query.updatedBefore !== undefined) {
+            sql += ' AND updated_at <= ?';
+            params.push(query.updatedBefore);
+        }
+        if (!query.includeExpired) {
+            sql += ' AND (expires_at IS NULL OR expires_at > ?)';
+            params.push(Date.now());
+        }
+        sql += ' ORDER BY created_at DESC';
+        if (query.limit) {
+            sql += ' LIMIT ?';
+            params.push(query.limit);
+        }
+        if (query.offset) {
+            sql += ' OFFSET ?';
+            params.push(query.offset);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        const results = [];
+        for (const row of rows) {
+            const entry = this.rowToEntry(row);
+            if (query.tags && query.tags.length > 0) {
+                if (!query.tags.every((tag) => entry.tags.includes(tag)))
+                    continue;
+            }
+            if (query.metadata) {
+                const ok = Object.entries(query.metadata).every(([k, v]) => entry.metadata[k] === v);
+                if (!ok)
+                    continue;
+            }
+            results.push(entry);
+        }
+        const duration = performance.now() - t0;
+        this.stats.queryCount++;
+        this.stats.totalQueryTime += duration;
+        this.emit('query:executed', { query, resultCount: results.length, duration });
+        return results;
+    }
+    async search(embedding, options) {
+        this.ensureInitialized();
+        const entries = await this.query({
+            type: 'hybrid',
+            limit: options.filters?.limit ?? 1000,
+        });
+        const results = [];
+        for (const entry of entries) {
+            if (!entry.embedding)
+                continue;
+            const similarity = cosineSimilarity(embedding, entry.embedding);
+            if (options.threshold !== undefined && similarity < options.threshold)
+                continue;
+            results.push({ entry, score: similarity, distance: 1 - similarity });
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, options.k);
+    }
+    async bulkInsert(entries) {
+        this.ensureInitialized();
+        // Wrap in a transaction so the whole batch lands atomically and shares
+        // one fsync — meaningful win for 100+ entry inserts. Guarded against
+        // re-entry: node:sqlite throws on nested BEGIN, so honor an outer
+        // transaction if a caller already opened one.
+        await this.runInTransaction(async () => {
+            for (const entry of entries)
+                await this.store(entry);
+        });
+        this.emit('bulk:inserted', { count: entries.length });
+    }
+    async bulkDelete(ids) {
+        this.ensureInitialized();
+        let count = 0;
+        await this.runInTransaction(async () => {
+            for (const id of ids) {
+                const ok = await this.delete(id);
+                if (ok)
+                    count++;
+            }
+        });
+        this.emit('bulk:deleted', { count });
+        return count;
+    }
+    /**
+     * Run `fn` inside a transaction, skipping BEGIN/COMMIT when one is already
+     * open. node:sqlite throws on nested BEGIN; better-sqlite3 has
+     * `db.transaction(fn)` for this, but the built-in engine doesn't.
+     */
+    async runInTransaction(fn) {
+        const owns = !this.db.isTransaction;
+        // BEGIN IMMEDIATE so busy_handler engages on multi-process contention
+        // (#1099 — plain BEGIN's read→write upgrade fails fast under WAL).
+        if (owns)
+            this.db.exec('BEGIN IMMEDIATE');
+        try {
+            await fn();
+            if (owns)
+                this.db.exec('COMMIT');
+        }
+        catch (err) {
+            if (owns) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch { /* already aborted */ }
+            }
+            throw err;
+        }
+    }
+    async count(namespace) {
+        this.ensureInitialized();
+        const row = namespace
+            ? this.stmts.countByNamespace.get(namespace)
+            : this.stmts.countAll.get();
+        return Number(row?.c ?? 0);
+    }
+    async listNamespaces() {
+        this.ensureInitialized();
+        const rows = this.stmts.listNamespaces.all();
+        return rows.map((r) => r.namespace);
+    }
+    async clearNamespace(namespace) {
+        this.ensureInitialized();
+        const before = await this.count(namespace);
+        this.stmts.deleteByNamespace.run(namespace);
+        this.emit('namespace:cleared', { namespace, count: before });
+        return before;
+    }
+    async getStats() {
+        this.ensureInitialized();
+        // Single GROUP BY scan replaces N namespace queries + 5 type queries
+        // (reviewer flag — getStats is called from health checks).
+        const rows = this.db
+            .prepare('SELECT namespace, type, COUNT(*) AS c FROM memory_entries GROUP BY namespace, type')
+            .all();
+        const entriesByNamespace = {};
+        const entriesByType = {
+            episodic: 0, semantic: 0, procedural: 0, working: 0, cache: 0,
+        };
+        let total = 0;
+        for (const row of rows) {
+            const ns = String(row.namespace);
+            const type = row.type;
+            const c = Number(row.c);
+            total += c;
+            entriesByNamespace[ns] = (entriesByNamespace[ns] ?? 0) + c;
+            if (type in entriesByType)
+                entriesByType[type] = (entriesByType[type] ?? 0) + c;
+        }
+        return {
+            totalEntries: total,
+            entriesByNamespace,
+            entriesByType,
+            memoryUsage: this.estimateMemoryUsage(),
+            avgQueryTime: this.stats.queryCount > 0
+                ? this.stats.totalQueryTime / this.stats.queryCount
+                : 0,
+            avgSearchTime: 0,
+        };
+    }
+    async healthCheck() {
+        const issues = [];
+        const storageStart = performance.now();
+        const storageHealthy = this.db !== null;
+        const storageLatency = performance.now() - storageStart;
+        if (!storageHealthy)
+            issues.push('Database not initialized');
+        const indexHealth = {
+            status: 'healthy',
+            latency: 0,
+            message: 'No vector index (brute-force search)',
+        };
+        const cacheHealth = {
+            status: 'healthy',
+            latency: 0,
+            message: 'No separate cache layer',
+        };
+        return {
+            status: issues.length === 0 ? 'healthy' : 'degraded',
+            components: {
+                storage: {
+                    status: storageHealthy ? 'healthy' : 'unhealthy',
+                    latency: storageLatency,
+                },
+                index: indexHealth,
+                cache: cacheHealth,
+            },
+            timestamp: Date.now(),
+            issues,
+            recommendations: ['Consider using MofloDbAdapter for HNSW-indexed vector search'],
+        };
+    }
+    /**
+     * No-op for parity with {@link SqlJsBackend.persist}. node:sqlite writes
+     * straight to the OS file handle — there is no in-memory image to flush.
+     */
+    async persist() {
+        if (!this.db || this.config.databasePath === ':memory:')
+            return;
+        // Checkpoint the WAL into the main DB file. The :memory: and readonly
+        // cases are already returned above, so a failure here is a real disk-
+        // level problem (disk full, locked file, corrupted WAL) — surface it.
+        try {
+            this.db.exec('PRAGMA wal_checkpoint(PASSIVE)');
+        }
+        catch (err) {
+            if (this.config.verbose) {
+                console.warn(`[SqliteBackend] wal_checkpoint failed: ${err.message}`);
+            }
+            this.emit('error', { operation: 'persist', error: err });
+        }
+        this.emit('persisted', { path: this.config.databasePath });
+    }
+    ensureInitialized() {
+        if (!this.initialized || !this.db) {
+            throw new Error('SqliteBackend not initialized. Call initialize() first.');
+        }
+    }
+    rowToEntry(row) {
+        return {
+            id: row.id,
+            key: row.key,
+            content: row.content,
+            embedding: row.embedding ? blobToFloat32(row.embedding, this.config.verbose) : undefined,
+            type: row.type,
+            namespace: row.namespace,
+            tags: JSON.parse(row.tags ?? '[]'),
+            metadata: JSON.parse(row.metadata ?? '{}'),
+            ownerId: row.owner_id ?? undefined,
+            accessLevel: row.access_level,
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+            expiresAt: row.expires_at != null ? Number(row.expires_at) : undefined,
+            version: Number(row.version ?? 1),
+            references: JSON.parse(row.references ?? '[]'),
+            accessCount: Number(row.access_count ?? 0),
+            lastAccessedAt: Number(row.last_accessed_at ?? 0),
+        };
+    }
+    updateAccessTracking(id) {
+        if (!this.db)
+            return;
+        this.stmts.updateAccess.run(Date.now(), id);
+    }
+    estimateMemoryUsage() {
+        if (!this.db || !this.cachedPageSize)
+            return 0;
+        try {
+            const row = this.db.prepare('PRAGMA page_count').get();
+            return Number(row?.page_count ?? 0) * this.cachedPageSize;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+/**
+ * Convert a stored embedding cell to Float32Array. Handles both BLOB shape
+ * (from {@link SqlJsBackend} / this backend) and TEXT-JSON shape (from DBs
+ * created via MEMORY_SCHEMA_V3 — the discrepancy called out in epic #1078
+ * Phase 0). Logs on malformed inputs because a silently-truncated embedding
+ * returns wrong search results.
+ */
+function blobToFloat32(cell, verbose) {
+    const toView = (view) => {
+        if (view.byteLength % 4 !== 0) {
+            if (verbose) {
+                console.warn(`[SqliteBackend] embedding BLOB byteLength ${view.byteLength} not aligned to Float32 — returning empty`);
+            }
+            return new Float32Array(0);
+        }
+        // Copy into a fresh ArrayBuffer so the returned view is detached from
+        // any SharedArrayBuffer the SQLite binding may hand us.
+        const copy = new Uint8Array(view.byteLength);
+        copy.set(view);
+        return new Float32Array(copy.buffer);
+    };
+    if (cell instanceof Uint8Array)
+        return toView(cell);
+    if (Buffer.isBuffer(cell))
+        return toView(cell);
+    if (typeof cell === 'string') {
+        try {
+            const arr = JSON.parse(cell);
+            return new Float32Array(Array.isArray(arr) ? arr : []);
+        }
+        catch {
+            if (verbose)
+                console.warn('[SqliteBackend] embedding TEXT cell unparseable — returning empty');
+            return new Float32Array(0);
+        }
+    }
+    return new Float32Array(0);
+}
+//# sourceMappingURL=sqlite-backend.js.map

package/dist/src/cli/memory/suppress-sqlite-warning.js

@@ -0,0 +1,49 @@
+/**
+ * Side-effect module — installs a `process.emitWarning` filter that drops
+ * Node's `ExperimentalWarning: SQLite is an experimental feature` line
+ * before `node:sqlite` ever fires it.
+ *
+ * TS twin of `bin/lib/suppress-sqlite-warning.mjs`. Imported at the top of
+ * `daemon-backend.ts` so any TS entry point (CLI command, MCP server, vitest
+ * test) that pulls in the bridge transitively also gets the filter.
+ *
+ * See the JS twin for the full rationale; the two MUST stay in lockstep so
+ * the symbol-based idempotency guard works whether the first import comes
+ * from JS or TS.
+ *
+ * @module v3/memory/suppress-sqlite-warning
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const INSTALLED = Symbol.for('moflo.suppressSqliteWarning.installed');
+function shouldSuppress(message) {
+    if (typeof message === 'string') {
+        return message.includes('SQLite is an experimental feature');
+    }
+    if (message && typeof message === 'object') {
+        const m = message.message;
+        return typeof m === 'string' && m.includes('SQLite is an experimental feature');
+    }
+    return false;
+}
+const g = globalThis;
+if (!g[INSTALLED]) {
+    g[INSTALLED] = true;
+    const originalEmitWarning = process.emitWarning.bind(process);
+    // Cast through `any` so we can pass both emit signatures —
+    // (message, type, code, ctor) and (message, options) — through unchanged.
+    process.emitWarning = function (warning, ...args) {
+        if (shouldSuppress(warning))
+            return;
+        const arg0 = args[0];
+        const typeArg = typeof arg0 === 'string'
+            ? arg0
+            : arg0 && typeof arg0 === 'object'
+                ? arg0.type
+                : undefined;
+        if (typeArg === 'ExperimentalWarning' && typeof warning === 'string' && warning.includes('SQLite'))
+            return;
+        originalEmitWarning(warning, ...args);
+    };
+}
+export {};
+//# sourceMappingURL=suppress-sqlite-warning.js.map