moflo 4.10.7 → 4.10.8

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

@@ -103,7 +103,7 @@ const storeCommand = {
             size: Buffer.byteLength(value, 'utf8')
         };
         output.printInfo(`Storing in ${namespace}/${key}...`);
-        // Use direct sql.js storage with automatic embedding generation
+        // Use direct memory-backend storage with automatic embedding generation
         try {
             const { storeEntry } = await import('../memory/memory-initializer.js');
             if (asVector) {
@@ -175,7 +175,7 @@ const retrieveCommand = {
             output.printError('Key is required');
             return { success: false, exitCode: 1 };
         }
-        // Use sql.js directly for consistent data access
+        // Use the memory backend directly for consistent data access
         try {
             const { getEntry } = await import('../memory/memory-initializer.js');
             const result = await getEntry({ key, namespace });
@@ -302,7 +302,7 @@ const searchCommand = {
         }
         output.printInfo(`Searching: "${query}" (${searchType})`);
         output.writeln();
-        // Use direct sql.js search with vector similarity
+        // Use direct memory-backend search with vector similarity
         try {
             const { searchEntries } = await import('../memory/memory-initializer.js');
             const searchResult = await searchEntries({
@@ -381,7 +381,7 @@ const listCommand = {
     action: async (ctx) => {
         const namespace = ctx.flags.namespace;
         const limit = ctx.flags.limit;
-        // Use sql.js directly for consistent data access
+        // Use the memory backend directly for consistent data access
         try {
             const { listEntries } = await import('../memory/memory-initializer.js');
             const listResult = await listEntries({ namespace, limit, offset: 0 });
@@ -499,7 +499,7 @@ const deleteCommand = {
                 return { success: true };
             }
         }
-        // Use sql.js directly for consistent data access (Issue #980)
+        // Use the memory backend directly for consistent data access (Issue #980)
         try {
             const { deleteEntry } = await import('../memory/memory-initializer.js');
             const result = await deleteEntry({ key, namespace });
@@ -1034,10 +1034,10 @@ const importCommand = {
         }
     }
 };
-// Init subcommand - initialize memory database using sql.js
+// Init subcommand - initialize memory database using node:sqlite
 const initMemoryCommand = {
     name: 'init',
-    description: 'Initialize memory database with sql.js (WASM SQLite) - includes vector embeddings, pattern learning, temporal decay',
+    description: 'Initialize memory database with node:sqlite (Node 22+ built-in) - includes vector embeddings, pattern learning, temporal decay',
     options: [
         {
             name: 'backend',
@@ -2637,7 +2637,7 @@ export const memoryCommand = {
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
-            `${output.highlight('init')}       - Initialize memory database (sql.js)`,
+            `${output.highlight('init')}       - Initialize memory database (node:sqlite)`,
             `${output.highlight('store')}      - Store data in memory`,
             `${output.highlight('retrieve')}   - Retrieve data from memory`,
             `${output.highlight('search')}     - Semantic/vector search`,

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

@@ -5,6 +5,8 @@
  * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
+import { findProjectRoot } from '../services/project-root.js';
+import { MOFLO_DIR } from '../services/moflo-paths.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 // Train subcommand - REAL WASM training with MoVector
 const trainCommand = {
@@ -673,8 +675,8 @@ const optimizeCommand = {
             await initializeIntelligence();
             const patterns = await getAllPatterns();
             const stats = getIntelligenceStats();
-            // Get actual pattern storage size
-            const patternDir = path.join(process.cwd(), '.moflo', 'neural');
+            // Get actual pattern storage size (#1152: anchor on projectRoot, not cwd)
+            const patternDir = path.join(findProjectRoot(), MOFLO_DIR, 'neural');
             let beforeSize = 0;
             try {
                 const patternFile = path.join(patternDir, 'patterns.json');
@@ -849,8 +851,8 @@ const exportCommand = {
                     totalUsage: 0,
                 },
             };
-            // Load patterns from local storage
-            const memoryDir = path.join(process.cwd(), '.moflo', 'memory');
+            // Load patterns from local storage (#1152: projectRoot-anchored)
+            const memoryDir = path.join(findProjectRoot(), MOFLO_DIR, 'memory');
             const patternsFile = path.join(memoryDir, 'patterns.json');
             if (fs.existsSync(patternsFile)) {
                 const patterns = JSON.parse(fs.readFileSync(patternsFile, 'utf8'));
@@ -1242,8 +1244,8 @@ const importCommand = {
             if (validPatterns.length < patterns.length) {
                 output.writeln(output.warning(`Filtered ${patterns.length - validPatterns.length} suspicious patterns`));
             }
-            // Save to local memory
-            const memoryDir = path.join(process.cwd(), '.moflo', 'memory');
+            // Save to local memory (#1152: projectRoot-anchored)
+            const memoryDir = path.join(findProjectRoot(), MOFLO_DIR, 'memory');
             if (!fs.existsSync(memoryDir)) {
                 fs.mkdirSync(memoryDir, { recursive: true });
             }

package/dist/src/cli/config/moflo-config.js

@@ -41,7 +41,7 @@ const DEFAULT_CONFIG = {
         code_map: true,
     },
     memory: {
-        backend: 'sql.js',
+        backend: 'node-sqlite',
         embedding_model: 'Xenova/all-MiniLM-L6-v2',
         namespace: 'default',
     },
@@ -138,6 +138,39 @@ function findConfigFile(root) {
 function positiveNumber(value, fallback) {
     return typeof value === 'number' && isFinite(value) && value > 0 ? value : fallback;
 }
+const VALID_MEMORY_BACKENDS = new Set([
+    'node-sqlite',
+    'sql.js',
+    'rvf',
+    'json',
+]);
+// Dedupe stderr warnings — `loadMofloConfig()` runs on every
+// `createDatabase()` call that omits an explicit provider, so a single
+// typo in moflo.yaml would otherwise spam N lines per process. Keyed by
+// the offending raw value so unrelated typos still each emit once.
+const _seenUnknownBackendWarnings = new Set();
+/**
+ * Validate a raw `memory.backend` value against the narrow union. Unknown
+ * values (previously: `agentdb`, future typos) fall back to the default
+ * with a one-line stderr warning so consumers don't silently get the wrong
+ * backend after a migration.
+ *
+ * `sql.js` is accepted here but normalised later by
+ * {@link resolveDatabaseProvider} — keeping it in the YAML-side type lets
+ * existing `moflo.yaml` files keep parsing across the upgrade.
+ */
+function coerceMemoryBackend(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return DEFAULT_CONFIG.memory.backend;
+    if (VALID_MEMORY_BACKENDS.has(raw))
+        return raw;
+    if (!_seenUnknownBackendWarnings.has(raw)) {
+        _seenUnknownBackendWarnings.add(raw);
+        process.stderr.write(`[moflo] WARNING: unknown memory.backend "${raw}" in moflo.yaml — ` +
+            `falling back to "${DEFAULT_CONFIG.memory.backend}". Valid: ${[...VALID_MEMORY_BACKENDS].join(', ')}.\n`);
+    }
+    return DEFAULT_CONFIG.memory.backend;
+}
 /**
  * Parse raw config object into typed config, merging with defaults.
  */
@@ -166,7 +199,7 @@ function mergeConfig(raw, root) {
             code_map: raw.auto_index?.code_map ?? raw.autoIndex?.code_map ?? DEFAULT_CONFIG.auto_index.code_map,
         },
         memory: {
-            backend: raw.memory?.backend || DEFAULT_CONFIG.memory.backend,
+            backend: coerceMemoryBackend(raw.memory?.backend),
             embedding_model: raw.memory?.embedding_model || raw.memory?.embeddingModel || DEFAULT_CONFIG.memory.embedding_model,
             namespace: raw.memory?.namespace || DEFAULT_CONFIG.memory.namespace,
         },
@@ -361,7 +394,7 @@ auto_index:
 
 # Memory backend
 memory:
-  backend: sql.js              # sql.js (WASM, no native deps) | agentdb | json
+  backend: node-sqlite         # node-sqlite (default) | rvf (pure-TS fallback) | json (last resort). Passed to createDatabase() as the preferred provider.
   embedding_model: Xenova/all-MiniLM-L6-v2
   namespace: default
 
@@ -471,4 +504,36 @@ export function writeMofloConfig(projectRoot) {
     fs.writeFileSync(configPath, content, 'utf-8');
     return configPath;
 }
+// Dedupe stderr deprecation messages — one banner per (process, deprecated
+// alias) keeps the noise to a single line per session even when multiple
+// subsystems (daemon + indexer + statusline) all load the same config.
+const _seenBackendDeprecations = new Set();
+/**
+ * Map a YAML-side `memory.backend` value to the runtime
+ * {@link ResolvedMemoryBackend}. `sql.js` (deprecated since Phase 5 / #1084)
+ * is rewritten to `node-sqlite` with a one-time stderr deprecation note so
+ * consumers see they need to update their `moflo.yaml` but the run still
+ * succeeds.
+ *
+ * Centralising the mapping here is the whole point of #1144: every future
+ * caller that opens a DB based on the user's YAML knob goes through this
+ * helper, so the YAML schema and the runtime selection can never drift.
+ */
+export function resolveDatabaseProvider(backend) {
+    if (backend === 'sql.js') {
+        if (!_seenBackendDeprecations.has(backend)) {
+            _seenBackendDeprecations.add(backend);
+            process.stderr.write(`[moflo] DEPRECATED: memory.backend "sql.js" in moflo.yaml — ` +
+                `sql.js was removed in Phase 5 (#1084). Using "node-sqlite" instead. ` +
+                `Update your moflo.yaml to silence this warning.\n`);
+        }
+        return 'node-sqlite';
+    }
+    return backend;
+}
+/** @internal — test hook only; resets the dedupe sets between cases. */
+export function _resetBackendDeprecations() {
+    _seenBackendDeprecations.clear();
+    _seenUnknownBackendWarnings.clear();
+}
 //# sourceMappingURL=moflo-config.js.map

package/dist/src/cli/index.js

@@ -519,30 +519,29 @@ export class CLI {
         }
     }
     /**
-     * Load configuration file
+     * Load moflo project configuration.
+     *
+     * Returns the user's `moflo.yaml` merged with defaults so command actions
+     * can read project settings directly. Prior versions invoked a v2→v3
+     * SystemConfig adapter — collapsed in #1144 because nothing actually read
+     * `ctx.config.*` and the parallel schema was a silent-drift bug class.
+     *
+     * `configPath` (the global `--config` flag) used to point at a
+     * claude-flow SystemConfig file. With the adapter gone, the flag has no
+     * runtime effect; we surface a one-line warning when a consumer passes
+     * it so the silent-no-op is visible rather than mysterious. A future
+     * flag-driven override can plumb a directory through to
+     * `loadMofloConfig()` without touching callers.
      */
     async loadConfig(configPath) {
+        if (configPath) {
+            this.output.printWarning(`--config "${configPath}" is no longer honoured — moflo loads moflo.yaml ` +
+                `from the project root directly (#1144).`);
+        }
         try {
-            // Import config utilities
-            const { loadConfig: loadSystemConfig } = await import('./shared/index.js');
-            const { systemConfigToV3Config } = await import('./config-adapter.js');
-            // Load configuration
-            const loaded = await loadSystemConfig({
-                file: configPath,
-                paths: configPath ? undefined : [process.cwd()],
-            });
-            // Convert to V3Config format
-            const v3Config = systemConfigToV3Config(loaded.config);
-            // Log warnings if any
-            if (loaded.warnings && loaded.warnings.length > 0) {
-                for (const warning of loaded.warnings) {
-                    this.output.printWarning(warning);
-                }
-            }
-            return v3Config;
+            return loadMofloConfig();
         }
         catch (error) {
-            // Config loading is optional - don't fail if it doesn't exist
             if (process.env.DEBUG) {
                 this.output.writeln(this.output.dim(`Config loading failed: ${error.message}`));
             }

package/dist/src/cli/init/moflo-yaml-template.js

@@ -215,7 +215,7 @@ auto_index:
 
 # Memory backend
 memory:
-  backend: sql.js
+  backend: node-sqlite
   embedding_model: Xenova/all-MiniLM-L6-v2
   namespace: default
 

package/dist/src/cli/mcp-server.js

@@ -24,19 +24,44 @@ import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { errorDetail } from './shared/utils/error-detail.js';
+import { findProjectRoot } from './services/project-root.js';
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
- * Default configuration
+ * Resolve the per-project `.moflo/` directory for MCP state files.
+ *
+ * Routed through the unified `findProjectRoot` so the launcher, daemon, healers
+ * and the MCP server all agree on the same anchor (see #1057, #1145).
+ * Replaces the prior `os.tmpdir()` location which was shared across every
+ * moflo consumer on the machine — concurrent projects overwrote each other's
+ * PID file and `flo mcp stop` could kill the wrong project's MCP server.
+ */
+function resolveMcpStateDir() {
+    return path.join(findProjectRoot(), '.moflo');
+}
+/**
+ * Legacy tmpdir paths (pre-#1151). Kept only so we can clean up dead PID
+ * files left behind by older moflo versions. Never written to.
  */
-const DEFAULT_OPTIONS = {
-    transport: 'stdio',
-    pidFile: path.join(os.tmpdir(), 'claude-flow-mcp.pid'),
-    logFile: path.join(os.tmpdir(), 'claude-flow-mcp.log'),
-    tools: 'all',
-    daemonize: false,
-};
+const LEGACY_TMPDIR_PID_FILE = path.join(os.tmpdir(), 'claude-flow-mcp.pid');
+const LEGACY_TMPDIR_LOG_FILE = path.join(os.tmpdir(), 'claude-flow-mcp.log');
+/**
+ * Build default configuration at construction time. PID/log paths resolve
+ * against `findProjectRoot()` so each project gets its own MCP state files
+ * under `<projectRoot>/.moflo/`. Lazy so test code that sets
+ * `CLAUDE_PROJECT_DIR` per-test sees the override.
+ */
+function buildDefaultOptions() {
+    const stateDir = resolveMcpStateDir();
+    return {
+        transport: 'stdio',
+        pidFile: path.join(stateDir, 'mcp-server.pid'),
+        logFile: path.join(stateDir, 'mcp-server.log'),
+        tools: 'all',
+        daemonize: false,
+    };
+}
 /**
  * MCP Server Manager
  *
@@ -49,7 +74,7 @@ export class MCPServerManager extends EventEmitter {
     healthCheckInterval;
     constructor(options = {}) {
         super();
-        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.options = { ...buildDefaultOptions(), ...options };
     }
     /**
      * Start the MCP server
@@ -461,11 +486,35 @@ export class MCPServerManager extends EventEmitter {
         this.healthCheckInterval.unref();
     }
     /**
-     * Write PID file
+     * Write PID file. Ensures the per-project state directory exists and opportunistically
+     * cleans up an abandoned tmpdir PID file (pre-#1151 layout) when it points at a dead
+     * PID — abandoned dead-PID files belong to nobody so we can safely unlink them, but
+     * a live tmpdir PID is left alone since it may belong to another project on an
+     * older moflo version.
      */
     async writePidFile() {
         const pid = this.process?.pid || process.pid;
+        await fs.promises.mkdir(path.dirname(this.options.pidFile), { recursive: true });
         await fs.promises.writeFile(this.options.pidFile, String(pid), 'utf8');
+        await this.cleanupAbandonedTmpdirPid();
+    }
+    /**
+     * Remove a stale `<tmpdir>/claude-flow-mcp.pid` left by a pre-#1151 moflo if
+     * the PID it points to is no longer running. Live PIDs are preserved so we
+     * don't break stop/status for another project still on the old layout.
+     */
+    async cleanupAbandonedTmpdirPid() {
+        try {
+            const legacy = await fs.promises.readFile(LEGACY_TMPDIR_PID_FILE, 'utf8');
+            const legacyPid = parseInt(legacy.trim(), 10);
+            if (!Number.isNaN(legacyPid) && !this.isProcessRunning(legacyPid)) {
+                await fs.promises.unlink(LEGACY_TMPDIR_PID_FILE).catch(() => { });
+                await fs.promises.unlink(LEGACY_TMPDIR_LOG_FILE).catch(() => { });
+            }
+        }
+        catch {
+            // No legacy file (the common path post-upgrade) — nothing to do.
+        }
     }
     /**
      * Read PID file

package/dist/src/cli/mcp-tools/memory-tools.js

@@ -1,17 +1,16 @@
 /**
- * Memory MCP Tools for CLI - V3 with sql.js/HNSW Backend
+ * Memory MCP Tools for CLI — node:sqlite + HNSW backend
  *
- * UPGRADED: Now uses the advanced sql.js + HNSW backend for:
- * - 150x-12,500x faster semantic search
- * - Vector embeddings with cosine similarity
- * - Persistent SQLite storage (WASM)
- * - Backward compatible with legacy JSON storage (auto-migrates)
+ * Backed by Node's built-in `node:sqlite` engine (Phase 4 #1083 flipped the
+ * default; Phase 5 #1084 deleted the prior sql.js path) plus an HNSW vector
+ * index for semantic search. Auto-migrates legacy JSON stores on first use.
  *
  * @module v3/cli/mcp-tools/memory-tools
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { GateService } from '../services/spell-gate.js';
+import { BACKEND_LABEL } from '../memory/database-provider.js';
 // Paths
 const MEMORY_DIR = '.moflo/memory';
 const LEGACY_MEMORY_FILE = 'store.json';
@@ -108,7 +107,7 @@ function shapeRetrievedEntry(entry) {
         hasEmbedding: entry.hasEmbedding,
         navigation: parseNavigation(entry.metadata, 'full'),
         found: true,
-        backend: 'sql.js + HNSW',
+        backend: BACKEND_LABEL,
     };
 }
 function validateMemoryInput(key, value, query) {
@@ -185,7 +184,7 @@ async function ensureInitialized() {
     if (hasLegacyStore()) {
         const legacyStore = loadLegacyStore();
         if (legacyStore && Object.keys(legacyStore.entries).length > 0) {
-            console.error('[MCP Memory] Migrating legacy JSON store to sql.js...');
+            console.error('[MCP Memory] Migrating legacy JSON store to node:sqlite...');
             let migrated = 0;
             for (const [key, entry] of Object.entries(legacyStore.entries)) {
                 try {
@@ -211,7 +210,7 @@ async function ensureInitialized() {
 export const memoryTools = [
     {
         name: 'memory_store',
-        description: 'Store a value in memory with vector embedding for semantic search (sql.js + HNSW backend). Upserts by default — pass upsert:false to fail on duplicate keys. Optional `metadata` lets chunk-row producers set the navigation fields (parentDoc, prevChunk, nextChunk, siblings, …) that `memory_get_neighbors` reads.',
+        description: 'Store a value in memory with vector embedding for semantic search (node:sqlite + HNSW backend). Upserts by default — pass upsert:false to fail on duplicate keys. Optional `metadata` lets chunk-row producers set the navigation fields (parentDoc, prevChunk, nextChunk, siblings, …) that `memory_get_neighbors` reads.',
         category: 'memory',
         inputSchema: {
             type: 'object',
@@ -268,7 +267,7 @@ export const memoryTools = [
                     storedAt: new Date().toISOString(),
                     hasEmbedding: !!result.embedding,
                     embeddingDimensions: result.embedding?.dimensions || null,
-                    backend: 'sql.js + HNSW',
+                    backend: BACKEND_LABEL,
                     storeTime: `${duration.toFixed(2)}ms`,
                     error: result.error,
                 };
@@ -387,7 +386,7 @@ export const memoryTools = [
                     query,
                     results,
                     total: results.length,
-                    backend: 'HNSW + sql.js',
+                    backend: BACKEND_LABEL,
                 };
             }
             catch (error) {
@@ -479,7 +478,7 @@ export const memoryTools = [
                     include,
                     neighbors,
                     total: neighbors.length,
-                    backend: 'sql.js + HNSW',
+                    backend: BACKEND_LABEL,
                 };
             }
             catch (error) {
@@ -524,7 +523,7 @@ export const memoryTools = [
                     key,
                     namespace,
                     deleted,
-                    backend: 'sql.js + HNSW',
+                    backend: BACKEND_LABEL,
                     ...(errorReason ? { error: errorReason } : {}),
                 };
             }
@@ -577,7 +576,7 @@ export const memoryTools = [
                     total: result.total,
                     limit,
                     offset,
-                    backend: 'sql.js + HNSW',
+                    backend: BACKEND_LABEL,
                 };
             }
             catch (error) {
@@ -601,27 +600,47 @@ export const memoryTools = [
         },
         handler: async () => {
             await ensureInitialized();
-            const { checkMemoryInitialization, listEntries } = await getMemoryFunctions();
+            const { checkMemoryInitialization } = await getMemoryFunctions();
             try {
                 const status = await checkMemoryInitialization();
-                const allEntries = await listEntries({ limit: 100000 });
-                // Count by namespace
-                const namespaces = {};
-                let withEmbeddings = 0;
-                for (const entry of allEntries.entries) {
-                    namespaces[entry.namespace] = (namespaces[entry.namespace] || 0) + 1;
-                    if (entry.hasEmbedding)
-                        withEmbeddings++;
+                // #1149 — server-side aggregation. The pre-fix path iterated every
+                // namespace via listEntries({limit:100000}) and tripped the daemon's
+                // `limit ≤ 10 000` cap → 400 → tryDaemonList defaulted total to 0 →
+                // the MCP tool silently reported zero entries on populated DBs.
+                // Route through the dedicated stats endpoint; on routed:false, run
+                // the same GROUP BY in-process so users always see real counts; on
+                // a daemon error, surface it rather than masking it as zero.
+                const { tryDaemonStats } = await import('../memory/daemon-write-client.js');
+                const routed = await tryDaemonStats();
+                let namespaces;
+                let totalEntries;
+                let withEmbeddings;
+                if (routed.routed && routed.data) {
+                    ({ namespaces, totalEntries, withEmbeddings } = routed.data);
+                }
+                else if (routed.routed && routed.error) {
+                    return {
+                        initialized: status.initialized,
+                        error: `daemon memory_stats failed: ${routed.error}`,
+                        backend: BACKEND_LABEL,
+                    };
+                }
+                else {
+                    const { getNamespaceCounts } = await import('../memory/memory-initializer.js');
+                    const direct = await getNamespaceCounts();
+                    namespaces = direct.namespaces;
+                    totalEntries = direct.total;
+                    withEmbeddings = direct.withEmbeddings;
                 }
                 return {
                     initialized: status.initialized,
-                    totalEntries: allEntries.total,
+                    totalEntries,
                     entriesWithEmbeddings: withEmbeddings,
-                    embeddingCoverage: allEntries.total > 0
-                        ? `${((withEmbeddings / allEntries.total) * 100).toFixed(1)}%`
+                    embeddingCoverage: totalEntries > 0
+                        ? `${((withEmbeddings / totalEntries) * 100).toFixed(1)}%`
                         : '0%',
                     namespaces,
-                    backend: 'sql.js + HNSW',
+                    backend: BACKEND_LABEL,
                     version: status.version || '3.0.0',
                     features: status.features || {
                         vectorEmbeddings: true,

package/dist/src/cli/memory/auto-memory-bridge.js

@@ -3,7 +3,7 @@
  *
  * Per ADR-048: Bridges Claude Code's auto memory (markdown files at
  * ~/.claude/projects/<project>/memory/) with claude-flow's unified memory
- * system (MofloDb: sql.js + HNSW).
+ * system (MofloDb: node:sqlite + HNSW).
  *
  * Auto memory files are human-readable markdown that Claude loads into its
  * system prompt. MEMORY.md (first 200 lines) is the entrypoint; topic files

package/dist/src/cli/memory/controllers/attestation-log.js

@@ -2,7 +2,7 @@
  * AttestationLog — moflo-owned append-only audit log (epic #464 Phase C2).
  *
  * Replaces `agentdb.AttestationLog`. Writes observability records into a
- * sql.js-backed table with a hash chain so tampering can be detected.
+ * SQLite table with a hash chain so tampering can be detected.
  *
  * Consumer surface (from src/cli/memory/memory-bridge.ts):
  *   - record({ operation, entryId, timestamp?, ...metadata })

package/dist/src/cli/memory/controllers/causal-graph.js

@@ -2,7 +2,7 @@
  * CausalGraph — moflo-owned causal edge store.
  *
  * Replaces `agentdb.CausalGraph.addEdge`. Stores typed edges between
- * memory-entry IDs in a sql.js-backed table with composite indexes so
+ * memory-entry IDs in a SQLite table with composite indexes so
  * CausalRecall's BFS walks don't hit a full scan on the relation filter.
  */
 import { clamp01, clampInt, parseJsonSafe } from './_shared.js';