moflo 4.10.7 → 4.10.9

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

@@ -5,7 +5,7 @@
  * shell-out where possible). Falls back to running the check's `fix` string
  * if it looks like an `npx`/`npm`/`claude` command.
  */
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmdirSync, unlinkSync, writeFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { output } from '../output.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
@@ -13,6 +13,7 @@ import { atomicWriteFileSync } from '../shared/utils/atomic-file-write.js';
 import { repairHookWiring } from '../services/hook-wiring.js';
 import { getDaemonLockHolder } from '../services/daemon-lock.js';
 import { findProjectRoot } from '../services/project-root.js';
+import { legacyMemoryDbPath, legacyMemoryDbBakPath, memoryDbPath, mofloDir } from '../services/moflo-paths.js';
 import { findZombieProcesses } from './doctor-zombies.js';
 import { inspectMcpConfigs } from './doctor-checks-config.js';
 import { installClaudeCode, runCommand } from './doctor-checks-runtime.js';
@@ -94,6 +95,131 @@ async function fixGateHealthHooks() {
     }
     return driftFixed && wiringFixed;
 }
+/**
+ * Migrate `.swarm/` residue to its canonical home and remove the legacy directory.
+ *
+ * Three categories of artifact:
+ *   1. `memory.db` (+ `.bak`)               — stale once `.moflo/moflo.db` exists; delete.
+ *   2. `q-learning-model.json` / `model-router-state.json` — live RL state.
+ *      Rename into `.moflo/movector/`. If the canonical target already exists
+ *      (consumer ran moflo on the new defaults before the auto-fix), the
+ *      canonical wins and the `.swarm/` copy is unlinked.
+ *   3. `hooks.log` / `background.log`       — diagnostic logs. Relocate to
+ *      `.moflo/logs/`; append into the canonical file if it already exists
+ *      so we don't drop history. Best-effort — log loss is acceptable.
+ *
+ * Finally `rmdir .swarm/` if and only if it's empty. Anything we didn't
+ * recognise is left in place rather than silently deleted.
+ *
+ * Cross-platform: uses `fs.rename`/`rmdir` (Node primitives), forward-slash-free
+ * joins via `path.join`. Works on Windows + POSIX.
+ *
+ * Returns true if the directory was fully retired OR if there was nothing to
+ * migrate; false if any relocation throws or `.swarm/` survives with unknown
+ * contents.
+ */
+async function fixSwarmLegacyResidue() {
+    const root = findProjectRoot();
+    const swarmDir = join(root, '.swarm');
+    if (!existsSync(swarmDir))
+        return true;
+    const canonicalDb = memoryDbPath(root);
+    const moflo = mofloDir(root);
+    const movectorDir = join(moflo, 'movector');
+    const logsDir = join(moflo, 'logs');
+    let allMigrated = true;
+    // (1) memory.db + .bak — both are migration artifacts of the launcher's
+    // copy-verify-rename step; if the canonical isn't yet in place neither
+    // source is safe to delete. The launcher creates the `.bak` only AFTER
+    // canonical exists, so this guard is conservative but correct.
+    const legacyDbPaths = [
+        ['memory.db', legacyMemoryDbPath(root)],
+        ['memory.db.bak', legacyMemoryDbBakPath(root)],
+    ];
+    for (const [name, src] of legacyDbPaths) {
+        if (!existsSync(src))
+            continue;
+        if (!existsSync(canonicalDb)) {
+            output.writeln(output.warning(`  Skipping ${name}: .moflo/moflo.db absent — run \`flo memory init\` first.`));
+            allMigrated = false;
+            continue;
+        }
+        try {
+            unlinkSync(src);
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Failed to delete ${name}: ${errorDetail(e)}`));
+            allMigrated = false;
+        }
+    }
+    // (2) router state JSONs — rename into .moflo/movector/.
+    const stateFiles = [
+        { name: 'q-learning-model.json', dest: movectorDir },
+        { name: 'model-router-state.json', dest: movectorDir },
+    ];
+    for (const { name, dest } of stateFiles) {
+        const src = join(swarmDir, name);
+        if (!existsSync(src))
+            continue;
+        const target = join(dest, name);
+        try {
+            mkdirSync(dest, { recursive: true });
+            if (existsSync(target)) {
+                // Canonical already populated by a fresh save on the new defaults.
+                // Keep the canonical, drop the legacy copy.
+                unlinkSync(src);
+            }
+            else {
+                renameSync(src, target);
+            }
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Failed to relocate ${name}: ${errorDetail(e)}`));
+            allMigrated = false;
+        }
+    }
+    // (3) logs — best-effort move. Append into canonical if it already exists
+    // (don't drop history). Hook + background logs are bounded to kilobytes in
+    // practice so the read-into-memory cost is acceptable.
+    const logFiles = ['hooks.log', 'background.log'];
+    for (const name of logFiles) {
+        const src = join(swarmDir, name);
+        if (!existsSync(src))
+            continue;
+        const target = join(logsDir, name);
+        try {
+            mkdirSync(logsDir, { recursive: true });
+            if (existsSync(target)) {
+                appendFileSync(target, readFileSync(src));
+                unlinkSync(src);
+            }
+            else {
+                renameSync(src, target);
+            }
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Failed to relocate ${name}: ${errorDetail(e)}`));
+            allMigrated = false;
+        }
+    }
+    // (4) rmdir .swarm/ if it's empty. Anything left is unrecognised — leave it
+    // for the user to inspect rather than silently delete.
+    try {
+        const remaining = readdirSync(swarmDir);
+        if (remaining.length === 0) {
+            rmdirSync(swarmDir);
+        }
+        else {
+            output.writeln(output.dim(`  .swarm/ kept (${remaining.length} unrecognised entr${remaining.length === 1 ? 'y' : 'ies'}): ${remaining.join(', ')}`));
+            allMigrated = false;
+        }
+    }
+    catch (e) {
+        output.writeln(output.warning(`  Failed to remove .swarm/: ${errorDetail(e)}`));
+        allMigrated = false;
+    }
+    return allMigrated;
+}
 /**
  * Execute the fix for a failed/warned health check.
  * Returns true if the fix succeeded (re-check should pass).
@@ -160,9 +286,29 @@ export async function autoFixCheck(check) {
                 return false;
             }
         },
+        // #1150 — SIGTERM the lock-holder BEFORE unlinking the lock. The old
+        // shape (`unlink lock; daemon start`) is the bug that produced orphan
+        // daemon accumulation: if the lock-holder PID was still alive, the
+        // unlink left it running and the respawn produced a second same-project
+        // daemon. Mirrors the 'Daemon Version Skew' / 'Daemon Identity Match'
+        // shape which got this right.
+        //
+        // Also reaps any same-project orphans whose PIDs aren't recorded in the
+        // lock — those are the daemons that survived prior buggy fixes.
         'Daemon Status': async () => {
-            const lockFile = join(process.cwd(), '.moflo', 'daemon.lock');
-            const pidFile = join(process.cwd(), '.moflo', 'daemon.pid');
+            const cwd = process.cwd();
+            const { getDaemonLockPayload, reapSameProjectOrphans } = await import('../services/daemon-lock.js');
+            const payload = getDaemonLockPayload(cwd);
+            if (payload?.pid && payload.pid > 0) {
+                try {
+                    process.kill(payload.pid, 'SIGTERM');
+                }
+                catch { /* already dead */ }
+            }
+            // Wipe other same-project daemons that the lock doesn't account for.
+            reapSameProjectOrphans(cwd);
+            const lockFile = join(cwd, '.moflo', 'daemon.lock');
+            const pidFile = join(cwd, '.moflo', 'daemon.pid');
             try {
                 if (existsSync(lockFile))
                     unlinkSync(lockFile);
@@ -195,6 +341,59 @@ export async function autoFixCheck(check) {
             catch { /* ok */ }
             return runFixCommand('npx moflo daemon start');
         },
+        // #1150 — terminate same-project orphan daemons. Keep the lock-holder
+        // alive if it shows up in the scan (it's the canonical daemon). If the
+        // lock-holder is missing/stale, kill all candidates and let the next
+        // session-start respawn a clean one. The pre-computed `pids` list is
+        // threaded into `reapSameProjectOrphans` so we don't re-run the
+        // OS process scan inside it.
+        'Daemon Orphan': async () => {
+            const cwd = process.cwd();
+            const { findProjectDaemonPids, getDaemonLockHolder, reapSameProjectOrphans } = await import('../services/daemon-lock.js');
+            const pids = findProjectDaemonPids(cwd);
+            if (pids.length <= 1)
+                return true; // already healthy
+            const lockHolder = getDaemonLockHolder(cwd);
+            if (lockHolder != null && pids.includes(lockHolder)) {
+                const { survived } = reapSameProjectOrphans(cwd, process.pid, lockHolder, pids);
+                return survived.length === 0;
+            }
+            // No identifiable canonical daemon — kill them all, clear the lock,
+            // respawn fresh.
+            const { survived } = reapSameProjectOrphans(cwd, process.pid, undefined, pids);
+            const lockFile = join(cwd, '.moflo', 'daemon.lock');
+            try {
+                if (existsSync(lockFile))
+                    unlinkSync(lockFile);
+            }
+            catch { /* ok */ }
+            if (survived.length > 0)
+                return false;
+            return runFixCommand('npx moflo daemon start');
+        },
+        // #1145 — daemon claims a different projectRoot than ours (or has no
+        // port in its lock so we can't verify). Same recycle pattern as version
+        // skew: SIGTERM the local daemon, clear the lock, respawn. Then the new
+        // daemon binds the per-project deterministic port and stamps it into
+        // the lock — clients can discover it without guessing.
+        'Daemon Identity Match': async () => {
+            const cwd = process.cwd();
+            const { getDaemonLockPayload } = await import('../services/daemon-lock.js');
+            const payload = getDaemonLockPayload(cwd);
+            if (payload?.pid && payload.pid > 0) {
+                try {
+                    process.kill(payload.pid, 'SIGTERM');
+                }
+                catch { /* already dead */ }
+            }
+            const lockFile = join(cwd, '.moflo', 'daemon.lock');
+            try {
+                if (existsSync(lockFile))
+                    unlinkSync(lockFile);
+            }
+            catch { /* ok */ }
+            return runFixCommand('npx moflo daemon start');
+        },
         'Embedding Coverage Truth': async () => {
             // Same as the existing Embeddings fix — rebuild the cache by re-running
             // the embeddings pipeline. Routes through `npx moflo` so the consumer
@@ -367,6 +566,12 @@ export async function autoFixCheck(check) {
                 return false;
             }
         },
+        // Migrate `.swarm/` residue (legacy memory.db, RL state JSONs, hook/bg logs)
+        // into their canonical `.moflo/` homes and rmdir the directory once empty.
+        // See `fixSwarmLegacyResidue` for the per-artifact policy.
+        'Swarm Residue': async () => {
+            return fixSwarmLegacyResidue();
+        },
         'Status Line': async () => {
             const settingsPath = join(process.cwd(), '.claude', 'settings.json');
             if (!existsSync(settingsPath))

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

@@ -12,7 +12,7 @@ import { checkWritersAudit } from './doctor-checks-writers-audit.js';
 import { checkSwarmFunctional, checkHiveMindFunctional, } from './doctor-checks-swarm.js';
 import { checkMemoryAccessFunctional } from './doctor-checks-memory-access.js';
 import { checkBuildTools, checkClaudeCode, checkDiskSpace, checkGit, checkGitRepo, checkNodeVersion, checkNpmVersion, } from './doctor-checks-runtime.js';
-import { checkConfigFile, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMemoryDbIntegrity, checkMofloYamlCompliance, checkStatusLine, checkTestDirs, } from './doctor-checks-config.js';
+import { checkConfigFile, checkDaemonIdentity, checkDaemonOrphan, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMemoryDbIntegrity, checkMofloYamlCompliance, checkStatusLine, checkSwarmResidue, checkTestDirs, } from './doctor-checks-config.js';
 import { checkSpellEngine, checkSandboxTier } from './doctor-checks-platform.js';
 import { checkEmbeddings, checkSemanticQuality, } from './doctor-checks-memory.js';
 import { checkIntelligence } from './doctor-checks-intelligence.js';
@@ -37,9 +37,15 @@ export const allChecks = [
     checkStatusLine,
     checkDaemonStatus,
     checkDaemonVersionSkew,
+    checkDaemonIdentity,
+    checkDaemonOrphan,
     checkDaemonWriteRouting,
     checkWritersAudit,
     checkMemoryDatabase,
+    // Surfaces leftover `.swarm/` artifacts (memory.db, router state, logs) so
+    // the auto-fix can relocate or delete them. Independent of the canonical
+    // DB checks — runs cheap (statSync only).
+    checkSwarmResidue,
     // Owns the corruption signal so downstream checks (Embeddings, Semantic
     // Quality, Memory Access Functional) don't surface it as the synthetic
     // "Check" failure (doctor.ts:214). MUST run after checkMemoryDatabase
@@ -95,9 +101,18 @@ export const componentMap = {
     'skew': checkDaemonVersionSkew,
     'daemon-write-routing': checkDaemonWriteRouting,
     'write-routing': checkDaemonWriteRouting,
+    'daemon-identity': checkDaemonIdentity,
+    'daemon-identity-match': checkDaemonIdentity,
+    'identity': checkDaemonIdentity,
+    'daemon-orphan': checkDaemonOrphan,
+    'daemon-orphans': checkDaemonOrphan,
+    'orphan': checkDaemonOrphan,
+    'orphans': checkDaemonOrphan,
     'writers-audit': checkWritersAudit,
     'writers': checkWritersAudit,
     'memory': checkMemoryDatabase,
+    'swarm-residue': checkSwarmResidue,
+    'residue': checkSwarmResidue,
     'memory-db-integrity': checkMemoryDbIntegrity,
     'integrity': checkMemoryDbIntegrity,
     'memory-integrity': checkMemoryDbIntegrity,

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