moflo 4.10.6 → 4.10.8

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',
     },
@@ -83,6 +83,7 @@ const DEFAULT_CONFIG = {
         scripts: true,
         helpers: true,
         hook_block_drift: 'warn',
+        claudemd_injection_drift: 'regenerate',
     },
     sandbox: {
         enabled: false,
@@ -137,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.
  */
@@ -165,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,
         },
@@ -212,6 +246,12 @@ function mergeConfig(raw, root) {
                     ? v
                     : DEFAULT_CONFIG.auto_update.hook_block_drift;
             })(),
+            claudemd_injection_drift: (() => {
+                const v = raw.auto_update?.claudemd_injection_drift ?? raw.autoUpdate?.claudemdInjectionDrift;
+                return v === 'regenerate' || v === 'off' || v === 'warn'
+                    ? v
+                    : DEFAULT_CONFIG.auto_update.claudemd_injection_drift;
+            })(),
         },
         sandbox: {
             enabled: raw.sandbox?.enabled ?? DEFAULT_CONFIG.sandbox.enabled,
@@ -354,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
 
@@ -409,6 +449,10 @@ auto_update:
                                  # warn = print drift summary on session start (default)
                                  # regenerate = auto-add missing hooks (only when no customisations)
                                  # off = skip detection entirely
+  claudemd_injection_drift: regenerate  # warn | regenerate | off
+                                 # regenerate = auto-refresh CLAUDE.md MoFlo block on drift (default)
+                                 # warn = print drift summary on session start
+                                 # off = skip detection entirely
 
 # OS-level sandbox for spell bash steps
 # Denylist always runs regardless of this setting
@@ -460,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/claudemd-generator.js

@@ -60,8 +60,12 @@ ${MARKER_END}`;
 export { MARKER_START, MARKER_END, LEGACY_MARKER_STARTS, LEGACY_MARKER_ENDS };
 /**
  * Generate the MoFlo section to inject into CLAUDE.md.
- * Template parameter is accepted for backward compatibility but ignored —
- * all templates now produce the same minimal injection.
+ *
+ * Both parameters are accepted for backward compatibility but ignored — all
+ * templates produce the same minimal injection and the options shape is no
+ * longer consulted. Optional so callers from both the dev tree (TS) and the
+ * dogfood launcher (plain JS) can invoke as `generateClaudeMd()` /
+ * `generateClaudeMd({})` interchangeably.
  */
 export function generateClaudeMd(_options, _template) {
     return mofloSection() + '\n';

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

@@ -15,7 +15,8 @@ import { execSync } from 'child_process';
 import { locateMofloRootPath } from '../services/moflo-require.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { discoverGuidanceDirs, discoverSrcDirs, discoverTestDirs, detectExtensions, renderMofloYaml, } from './moflo-yaml-template.js';
-import { generateClaudeMd as generateMofloSection, MARKER_START, MARKER_END, LEGACY_MARKER_STARTS, LEGACY_MARKER_ENDS, } from './claudemd-generator.js';
+import { generateClaudeMd as generateMofloSection } from './claudemd-generator.js';
+import { applyInjectionReplacement } from '../services/claudemd-injection.js';
 import { DEFAULT_INIT_OPTIONS } from './types.js';
 export { discoverTestDirs };
 // ============================================================================
@@ -400,29 +401,20 @@ function generateSkill(root, force) {
 // ============================================================================
 function generateClaudeMd(root, _force) {
     const claudeMdPath = path.join(root, 'CLAUDE.md');
-    let existing = '';
-    if (fs.existsSync(claudeMdPath)) {
-        existing = fs.readFileSync(claudeMdPath, 'utf-8');
-        // Strip current or legacy MoFlo block so we can re-inject the latest content.
-        const allStartMarkers = [MARKER_START, ...LEGACY_MARKER_STARTS];
-        const allEndMarkers = [MARKER_END, ...LEGACY_MARKER_ENDS];
-        for (let i = 0; i < allStartMarkers.length; i++) {
-            if (existing.includes(allStartMarkers[i])) {
-                const startIdx = existing.indexOf(allStartMarkers[i]);
-                const endIdx = existing.indexOf(allEndMarkers[i]);
-                if (endIdx > startIdx) {
-                    existing = existing.substring(0, startIdx) + existing.substring(endIdx + allEndMarkers[i].length);
-                }
-            }
-        }
-    }
-    // Single source of truth: claudemd-generator.ts owns the section content.
+    const existed = fs.existsSync(claudeMdPath);
+    const existing = existed ? fs.readFileSync(claudeMdPath, 'utf-8') : null;
+    // Single source of truth: claudemd-generator.ts owns the section content,
+    // claudemd-injection.ts owns the marker-replace logic. Replaces in place
+    // when a marker pair (current or legacy) already exists; otherwise creates
+    // a fresh CLAUDE.md or appends to a non-moflo one.
     const canonical = generateMofloSection(DEFAULT_INIT_OPTIONS);
-    const finalContent = existing.trimEnd() + '\n\n' + canonical;
-    fs.writeFileSync(claudeMdPath, finalContent, 'utf-8');
+    const result = applyInjectionReplacement(existing, canonical);
+    if (result.contents !== null && (result.changed || !existed)) {
+        fs.writeFileSync(claudeMdPath, result.contents, 'utf-8');
+    }
     return {
         name: 'CLAUDE.md',
-        status: existing ? 'updated' : 'created',
+        status: existed ? 'updated' : 'created',
         detail: 'MoFlo section injected (~22 lines)',
     };
 }

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';