moflo 4.9.36 → 4.10.0

package/dist/src/cli/services/learning-service.js

@@ -1,22 +1,21 @@
 /**
  * Learning Service
  *
- * Persistent pattern learning with HNSW indexing and sql.js backend.
+ * Persistent pattern learning with HNSW indexing and node:sqlite backend.
  * Manages short-term and long-term pattern storage with automatic
  * promotion, deduplication, and consolidation.
  *
  * Features:
- * - Pattern storage/search with sql.js backend (.moflo/moflo.db)
+ * - Pattern storage/search with node:sqlite backend (.moflo/moflo.db)
  * - Short-term -> long-term pattern promotion (promote after 3 uses)
  * - Quality thresholds: minimum quality 0.6, dedup threshold 0.95
  * - Consolidation: max 500 short-term, 2000 long-term, prune after 30 days
  * - HNSW indexing for fast similarity search
  */
-import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
-import { mofloImport } from './moflo-require.js';
-import { atomicWriteFileSync } from './atomic-file-write.js';
 import { memoryDbPath } from './moflo-paths.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { createNeuralEmbeddingProvider, } from './neural-embedding-provider.js';
 // ============================================================================
 // Configuration
@@ -212,11 +211,6 @@ class HNSWIndex {
         }
     }
 }
-async function loadSqlJs() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const initSqlJs = (await mofloImport('sql.js')).default;
-    return initSqlJs();
-}
 function dbAll(db, sql, params = []) {
     const stmt = db.prepare(sql);
     if (params.length)
@@ -283,14 +277,10 @@ export class LearningService {
         if (!existsSync(dataDir)) {
             mkdirSync(dataDir, { recursive: true });
         }
-        const SQL = await loadSqlJs();
-        if (existsSync(this.dbPath)) {
-            const buffer = readFileSync(this.dbPath);
-            this.db = new SQL.Database(buffer);
-        }
-        else {
-            this.db = new SQL.Database();
-        }
+        // node:sqlite via the unified factory (Phase 5 / #1084). The factory
+        // creates the file lazily and applies WAL pragma so every UPDATE below
+        // persists incrementally — no whole-file dumps via export().
+        this.db = openDaemonDatabase(this.dbPath);
         this.ensureSchema();
         this.loadIndexes();
     }
@@ -485,12 +475,14 @@ export class LearningService {
         }
     }
     /**
-     * Save DB to disk.
+     * Persist any in-memory changes. node:sqlite + WAL writes incrementally
+     * on every `db.run`, so this is just a state-clear — the actual data hit
+     * disk when the mutations ran. Phase 5 (#1084) removed the explicit
+     * `db.export()` + atomicWriteFileSync (sql.js whole-file dump).
      */
     save() {
         if (!this.db)
             return;
-        atomicWriteFileSync(this.dbPath, this.db.export());
         this.dirty = false;
     }
     // --------------------------------------------------------------------------

package/dist/src/cli/services/project-root.js

@@ -1,21 +1,81 @@
 /**
- * Project Root Discovery
+ * Project Root Discovery — canonical resolver.
  *
- * Walks up from cwd to find the nearest directory containing package.json or .git.
- * Extracted from spell-tools.ts for reuse (#229).
+ * Walks up from cwd to find the project's anchor directory using the same
+ * algorithm as `src/cli/memory/bridge-core.ts:getProjectRoot()` and the pure-JS
+ * twin at `bin/lib/moflo-paths.mjs:findProjectRoot()`. Every writer that
+ * touches `.moflo/moflo.db` (bin scripts, MCP tools, healers, daemon) MUST
+ * resolve through this single algorithm or its JS twin — otherwise different
+ * writers land on different DBs and the bridge reads stale data.
+ *
+ * Algorithm (#1057) — two-pass walk so memory markers always win:
+ *   1. `process.env.CLAUDE_PROJECT_DIR`, if set (Claude Code / explicit override).
+ *   2. **High-priority pass.** Walk from `opts.cwd ?? process.cwd()` up to the
+ *      filesystem root, looking at each level for (in order):
+ *        a. `<dir>/.moflo/moflo.db`            — canonical memory DB marker
+ *        b. `<dir>/.swarm/memory.db`           — legacy memory DB marker (pre-#727)
+ *        c. `<dir>/CLAUDE.md` AND `<dir>/package.json` — project marker pair
+ *      If anything matches, return that dir. `node_modules` segments are
+ *      skipped (npx run can land cwd inside one).
+ *   3. **Low-priority pass.** Walk again from cwd up to root looking for:
+ *        d. `<dir>/package.json`               — generic project marker
+ *        e. `<dir>/.git`                       — git repo marker
+ *      Return the first match.
+ *   4. Fall back to `opts.cwd ?? process.cwd()`.
+ *
+ * Why two passes? An upstream `.moflo/moflo.db` MUST win over a nested
+ * `package.json` (monorepo sub-package case) — otherwise the writer lands on
+ * a different DB than the bridge. Doing it in a single pass with bare
+ * `package.json` as a per-level marker would short-circuit at the nearest
+ * package.json before ever seeing the upstream memory marker.
+ *
+ * Story #229 history: this function was first extracted from workflow-tools.ts;
+ * #1057 brought it into alignment with bridge-core.getProjectRoot().
  */
 import { existsSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-export function findProjectRoot() {
-    let dir = process.cwd();
-    while (true) {
-        if (existsSync(resolve(dir, 'package.json')) || existsSync(resolve(dir, '.git'))) {
+import { resolve, dirname, parse, join, basename } from 'node:path';
+export function findProjectRoot(opts) {
+    const honorEnv = opts?.honorEnv !== false;
+    if (honorEnv && process.env.CLAUDE_PROJECT_DIR) {
+        return process.env.CLAUDE_PROJECT_DIR;
+    }
+    const startDir = opts?.cwd ?? process.cwd();
+    const start = resolve(startDir);
+    const fsRoot = parse(start).root;
+    // High-priority pass: memory markers + CLAUDE.md/package.json pair.
+    let dir = start;
+    while (dir !== fsRoot) {
+        if (basename(dir) === 'node_modules') {
+            dir = dirname(dir);
+            continue;
+        }
+        if (existsSync(join(dir, '.moflo', 'moflo.db')))
+            return dir;
+        if (existsSync(join(dir, '.swarm', 'memory.db')))
+            return dir;
+        if (existsSync(join(dir, 'CLAUDE.md')) && existsSync(join(dir, 'package.json'))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Low-priority pass: bare package.json or .git.
+    dir = start;
+    while (dir !== fsRoot) {
+        if (basename(dir) === 'node_modules') {
+            dir = dirname(dir);
+            continue;
+        }
+        if (existsSync(join(dir, 'package.json')) || existsSync(join(dir, '.git'))) {
             return dir;
         }
         const parent = dirname(dir);
         if (parent === dir)
-            return process.cwd(); // reached filesystem root
+            break;
         dir = parent;
     }
+    return startDir;
 }
 //# sourceMappingURL=project-root.js.map

package/dist/src/cli/services/soft-delete-purge.js

@@ -17,9 +17,8 @@
  * @module cli/services/soft-delete-purge
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { mofloImport } from './moflo-require.js';
-import { atomicWriteFileSync } from './atomic-file-write.js';
 import { memoryDbPath } from './moflo-paths.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 /**
  * Hard-delete all `status='deleted'` rows from the memory DB and VACUUM.
  *
@@ -34,12 +33,9 @@ export async function purgeSoftDeletedEntries(options = {}) {
     const dbPath = path.resolve(options.dbPath ?? memoryDbPath(process.cwd()));
     if (!fs.existsSync(dbPath))
         return { purged: 0 };
-    const initSqlJs = (await mofloImport('sql.js'))?.default;
-    if (!initSqlJs)
-        return { purged: 0 };
-    const SQL = await initSqlJs();
-    const buffer = fs.readFileSync(dbPath);
-    const db = new SQL.Database(buffer);
+    // node:sqlite via the unified factory (Phase 5 / #1084). WAL persists each
+    // DELETE/VACUUM incrementally; no atomicWriteFileSync needed.
+    const db = openDaemonDatabase(dbPath);
     try {
         // Probe: schema must carry `memory_entries`. Older / non-moflo DBs are
         // a no-op so we don't VACUUM unrelated SQLite files.
@@ -53,10 +49,9 @@ export async function purgeSoftDeletedEntries(options = {}) {
         if (purged === 0)
             return { purged: 0 };
         db.run(`DELETE FROM memory_entries WHERE status = 'deleted'`);
-        // VACUUM has to run outside any open transaction; sql.js auto-commits
-        // each `db.run`, so this is safe to chain.
+        // VACUUM has to run outside any open transaction; node:sqlite/sql.js
+        // both auto-commit each `db.run`, so this is safe to chain.
         db.run('VACUUM');
-        atomicWriteFileSync(dbPath, db.export());
         return { purged };
     }
     finally {

package/dist/src/cli/services/sqljs-migration-store.js

@@ -226,7 +226,10 @@ export class SqlJsMemoryEntriesStore {
     async beginTransaction() {
         if (this.inTransaction)
             return;
-        this.db.run('BEGIN');
+        // BEGIN IMMEDIATE — busy_handler engages on RESERVED acquisition under
+        // contention (#1099). Plain `BEGIN` (= deferred) would race the
+        // SHARED→RESERVED upgrade and fail fast against concurrent writers.
+        this.db.run('BEGIN IMMEDIATE');
         this.inTransaction = true;
     }
     async commit() {

package/dist/src/cli/services/subagent-bootstrap.js

@@ -21,7 +21,7 @@ const BOOTSTRAP_JSON_REL = '.claude/helpers/subagent-bootstrap.json';
 // Defense-in-depth copy of the canonical directive in subagent-bootstrap.json.
 // Kept as a single-line literal so the parity test can verify it matches the
 // JSON via plain substring containment.
-const FALLBACK_DIRECTIVE = 'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. After memory search, follow `.claude/guidance/moflo-subagents.md` protocol.';
+const FALLBACK_DIRECTIVE = 'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. After memory search, follow `.claude/guidance/moflo-subagents.md` protocol. When a search hit carries `navigation`, you MUST call mcp__moflo__memory_get_neighbors to traverse — calling mcp__moflo__memory_retrieve on every hit is a protocol violation. See `.claude/guidance/moflo-memory-protocol.md`.';
 function loadDirective() {
     const jsonPath = locateMofloRootPath(BOOTSTRAP_JSON_REL);
     if (!jsonPath) {

package/dist/src/cli/shared/events/event-store.js

@@ -10,13 +10,17 @@
  * - Event filtering and queries
  * - Snapshot support for performance
  * - Event replay for projections
- * - Cross-platform SQLite (sql.js fallback)
+ * - node:sqlite (Node 22+) via the unified openDaemonDatabase factory
+ *
+ * Phase 5 (#1084) migrated this from sql.js to node:sqlite. The sql.js
+ * whole-file-export persistence model was the structural failure mode that
+ * #1078 killed; node:sqlite writes through WAL so explicit `persist()` calls
+ * become no-ops and concurrent writers no longer clobber each other.
  *
  * @module v3/shared/events/event-store
  */
 import { EventEmitter } from 'node:events';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import initSqlJs from 'sql.js';
+import { openDaemonDatabase } from '../../memory/daemon-backend.js';
 const DEFAULT_CONFIG = {
     databasePath: ':memory:',
     verbose: false,
@@ -31,7 +35,6 @@ export class EventStore extends EventEmitter {
     db = null;
     initialized = false;
     persistTimer = null;
-    SQL = null;
     // Version tracking per aggregate
     aggregateVersions = new Map();
     constructor(config = {}) {
@@ -39,72 +42,41 @@ export class EventStore extends EventEmitter {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
     /**
-     * Initialize the event store
+     * Initialize the event store.
+     *
+     * Phase 5 (#1084): swapped sql.js's WASM init + new SQL.Database round-trip
+     * for openDaemonDatabase(path). WAL persists each INSERT incrementally so
+     * the auto-persist timer is no longer needed (kept zeroed-out for callers
+     * that pass autoPersistInterval > 0).
      */
     async initialize() {
         if (this.initialized)
             return;
-        // Load sql.js WASM — prefer local node_modules copy over remote URL
-        this.SQL = await initSqlJs({
-            locateFile: this.config.wasmPath
-                ? () => this.config.wasmPath
-                : (file) => {
-                    // Try to resolve from node_modules first (works in Node.js)
-                    try {
-                        const sqlJsDir = require.resolve('sql.js');
-                        const { dirname, join } = require('node:path');
-                        const localPath = join(dirname(sqlJsDir), file);
-                        if (require('node:fs').existsSync(localPath))
-                            return localPath;
-                    }
-                    catch { /* fallback below */ }
-                    return `https://sql.js.org/dist/${file}`;
-                },
-        });
-        // Load existing database if exists
-        if (this.config.databasePath !== ':memory:' && existsSync(this.config.databasePath)) {
-            const buffer = readFileSync(this.config.databasePath);
-            this.db = new this.SQL.Database(new Uint8Array(buffer));
-            if (this.config.verbose) {
-                console.log(`[EventStore] Loaded database from ${this.config.databasePath}`);
-            }
-        }
-        else {
-            this.db = new this.SQL.Database();
-            if (this.config.verbose) {
-                console.log('[EventStore] Created new event store database');
-            }
+        this.db = openDaemonDatabase(this.config.databasePath);
+        if (this.config.verbose) {
+            console.log(`[EventStore] Opened database at ${this.config.databasePath}`);
         }
         // Create schema
         this.createSchema();
         // Load aggregate versions
         this.loadAggregateVersions();
-        // Set up auto-persist
-        if (this.config.autoPersistInterval > 0 && this.config.databasePath !== ':memory:') {
-            this.persistTimer = setInterval(() => {
-                this.persist().catch((err) => {
-                    this.emit('error', { operation: 'auto-persist', error: err });
-                });
-            }, this.config.autoPersistInterval);
-        }
+        // node:sqlite + WAL persists every write — explicit auto-persist would
+        // be a redundant no-op. The persistTimer field is retained so anything
+        // poking at .initialize() shape stays compatible.
         this.initialized = true;
         this.emit('initialized');
     }
     /**
-     * Shutdown the event store
+     * Shutdown the event store. node:sqlite + WAL persists writes immediately;
+     * the only thing close() owes us is releasing the file handle.
      */
     async shutdown() {
         if (!this.initialized || !this.db)
             return;
-        // Stop auto-persist
         if (this.persistTimer) {
             clearInterval(this.persistTimer);
             this.persistTimer = null;
         }
-        // Final persist
-        if (this.config.databasePath !== ':memory:') {
-            await this.persist();
-        }
         this.db.close();
         this.db = null;
         this.initialized = false;
@@ -343,19 +315,18 @@ export class EventStore extends EventEmitter {
         };
     }
     /**
-     * Persist to disk
+     * Persist to disk. node:sqlite + WAL writes through on each `db.run`, so
+     * this is a no-op kept for API compatibility with the old sql.js shape.
+     * The `persisted` event still fires so callers driven off it keep working.
      */
     async persist() {
         if (!this.db || this.config.databasePath === ':memory:') {
             return;
         }
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.config.databasePath, buffer);
         if (this.config.verbose) {
-            console.log(`[EventStore] Persisted ${buffer.length} bytes to ${this.config.databasePath}`);
+            console.log(`[EventStore] persist() is a no-op under node:sqlite WAL (${this.config.databasePath})`);
         }
-        this.emit('persisted', { size: buffer.length, path: this.config.databasePath });
+        this.emit('persisted', { size: 0, path: this.config.databasePath });
     }
     // ===== Private Methods =====
     createSchema() {

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.9.36';
+export const VERSION = '4.10.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.9.36",
+  "version": "4.10.0",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -69,7 +69,6 @@
     "lru-cache": "^11.3.5",
     "onnxruntime-node": "^1.24.3",
     "semver": "^7.7.4",
-    "sql.js": "^1.14.1",
     "tar": "^7.5.11",
     "valibot": "^1.3.1"
   },
@@ -93,11 +92,10 @@
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.12.2",
-    "@types/sql.js": "^1.4.9",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.9.35",
+    "moflo": "^4.9.37",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"