moflo 4.9.0-rc.1 → 4.9.0-rc.2

package/.claude/helpers/statusline.cjs

@@ -256,13 +256,15 @@ function formatModelName(modelId) {
   return 'Claude Code';
 }
 
-// Get learning stats from memory database (pure stat calls)
+// Get learning stats from memory database (pure stat calls).
+// Canonical first (post-#727), then legacy paths. Keep in lockstep with
+// `memoryDbCandidatePaths` in src/cli/services/moflo-paths.ts.
 function getLearningStats() {
   const memoryPaths = [
+    path.join(CWD, '.moflo', 'moflo.db'),
     path.join(CWD, '.swarm', 'memory.db'),
-    path.join(CWD, '.moflo', 'memory.db'),
-    path.join(CWD, '.claude', 'memory.db'),
     path.join(CWD, 'data', 'memory.db'),
+    path.join(CWD, '.claude', 'memory.db'),
     path.join(CWD, '.agentdb', 'memory.db'),
   ];
 
@@ -506,12 +508,13 @@ function getAgentDBStats() {
     return { vectorCount, dbSizeKB, namespaces, hasHnsw };
   }
 
-  // Fallback: estimate from DB file size (no subprocess)
+  // Fallback: estimate from DB file size (no subprocess). Same probe order
+  // as `getLearningStats` above — see comment there.
   const dbFiles = [
+    path.join(CWD, '.moflo', 'moflo.db'),
     path.join(CWD, '.swarm', 'memory.db'),
-    path.join(CWD, '.moflo', 'memory.db'),
-    path.join(CWD, '.claude', 'memory.db'),
     path.join(CWD, 'data', 'memory.db'),
+    path.join(CWD, '.claude', 'memory.db'),
   ];
   for (const f of dbFiles) {
     const stat = safeStat(f);
@@ -524,8 +527,8 @@ function getAgentDBStats() {
   }
 
   const hnswPaths = [
-    path.join(CWD, '.swarm', 'hnsw.index'),
     path.join(CWD, '.moflo', 'hnsw.index'),
+    path.join(CWD, '.swarm', 'hnsw.index'), // legacy pre-#727
   ];
   for (const p of hnswPaths) {
     if (safeStat(p)) {
@@ -592,7 +595,7 @@ function getIntegrationStatus() {
     }
   }
 
-  const hasDatabase = ['.swarm/memory.db', '.moflo/memory.db', 'data/memory.db']
+  const hasDatabase = ['.moflo/moflo.db', '.swarm/memory.db', 'data/memory.db']
     .some(p => fs.existsSync(path.join(CWD, p)));
   const hasApi = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY);
 

package/bin/build-embeddings.mjs

@@ -19,6 +19,7 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { mofloResolveURL, mofloInternalURL } from './lib/moflo-resolve.mjs';
+import { memoryDbPath, hnswIndexPath } from './lib/moflo-paths.mjs';
 const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 const FASTEMBED_INLINE = 'dist/src/cli/embeddings/fastembed-inline/index.js';
 const BRIDGE_CORE = 'dist/src/cli/memory/bridge-core.js';
@@ -35,7 +36,7 @@ function findProjectRoot() {
 }
 
 const projectRoot = findProjectRoot();
-const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
+const DB_PATH = memoryDbPath(projectRoot);
 
 // Canonical model name emitted into `memory_entries.embedding_model`. The
 // semantic-search bin script accepts this plus a short set of legacy aliases
@@ -182,8 +183,7 @@ function getEmbeddingStats(db) {
 function writeVectorStatsCache(stats, nsStats) {
   try {
     const dbSizeKB = Math.floor(readFileSync(DB_PATH).length / 1024);
-    const hasHnsw = existsSync(resolve(projectRoot, '.swarm', 'hnsw.index'))
-      || existsSync(resolve(projectRoot, '.moflo', 'hnsw.index'));
+    const hasHnsw = existsSync(hnswIndexPath(projectRoot));
     const missing = nsStats.reduce((sum, ns) => sum + (ns.missing || 0), 0);
     writeVectorStatsJson(projectRoot, {
       vectorCount: stats.withEmbeddings,
@@ -263,8 +263,8 @@ async function main() {
   if (embedded > 0) {
     saveDb(db);
     for (const p of [
-      resolve(projectRoot, '.swarm/hnsw.index'),
-      resolve(projectRoot, '.swarm/hnsw.metadata.json'),
+      hnswIndexPath(projectRoot),
+      resolve(projectRoot, '.moflo', 'hnsw.metadata.json'),
     ]) {
       if (existsSync(p)) {
         unlinkSync(p);

package/bin/generate-code-map.mjs

@@ -2,7 +2,7 @@
 /**
  * Generate structural code map for a monorepo or project.
  *
- * Produces five chunk types stored in the `code-map` namespace of .swarm/memory.db:
+ * Produces five chunk types stored in the `code-map` namespace of .moflo/moflo.db:
  *   1. project:    — one per top-level project directory (bird's-eye overview)
  *   2. dir:        — one per directory with 2+ exported types (drill-down detail)
  *   3. iface-map:  — batched interface-to-implementation mappings
@@ -31,6 +31,7 @@ import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { execSync, execFileSync, spawn } from 'child_process';
 import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+import { memoryDbPath, MOFLO_DIR } from './lib/moflo-paths.mjs';
 const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 
 
@@ -49,8 +50,8 @@ function findProjectRoot() {
 
 const projectRoot = findProjectRoot();
 const NAMESPACE = 'code-map';
-const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
-const HASH_CACHE_PATH = resolve(projectRoot, '.swarm/code-map-hash.txt');
+const DB_PATH = memoryDbPath(projectRoot);
+const HASH_CACHE_PATH = resolve(projectRoot, MOFLO_DIR, 'code-map-hash.txt');
 
 // Directories to exclude from indexing
 const EXCLUDE_DIRS = [

package/bin/index-guidance.mjs

@@ -26,6 +26,7 @@ import { existsSync, readdirSync, readFileSync, statSync, mkdirSync, writeFileSy
 import { resolve, relative, dirname, basename, extname } from 'path';
 import { fileURLToPath } from 'url';
 import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+import { memoryDbPath } from './lib/moflo-paths.mjs';
 const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 
 
@@ -47,7 +48,7 @@ const projectRoot = findProjectRoot();
 const mofloRoot = resolve(__dirname, '..');
 
 const NAMESPACE = 'guidance';
-const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
+const DB_PATH = memoryDbPath(projectRoot);
 
 // ============================================================================
 // Load guidance directories from moflo.yaml, falling back to defaults
@@ -883,7 +884,7 @@ if (!skipEmbeddings && needsEmbeddings) {
     const embeddingArgs = ['--namespace', NAMESPACE];
 
     // Create log file for background process output
-    const logDir = resolve(projectRoot, '.swarm/logs');
+    const logDir = resolve(projectRoot, '.moflo/logs');
     if (!existsSync(logDir)) {
       mkdirSync(logDir, { recursive: true });
     }
@@ -902,7 +903,7 @@ if (!skipEmbeddings && needsEmbeddings) {
     proc.unref();  // Allow parent to exit independently
 
     log(`Background embedding started (PID: ${proc.pid})`);
-    log(`Log file: .swarm/logs/embeddings.log`);
+    log(`Log file: .moflo/logs/embeddings.log`);
   } else {
     log('⚠️  Embedding script not found, skipping embedding generation');
   }

package/bin/index-patterns.mjs

@@ -30,6 +30,7 @@ import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { spawn } from 'child_process';
 import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+import { memoryDbPath, MOFLO_DIR } from './lib/moflo-paths.mjs';
 const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -46,8 +47,8 @@ function findProjectRoot() {
 
 const projectRoot = findProjectRoot();
 const NAMESPACE = 'patterns';
-const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
-const HASH_CACHE_PATH = resolve(projectRoot, '.swarm/patterns-hash.txt');
+const DB_PATH = memoryDbPath(projectRoot);
+const HASH_CACHE_PATH = resolve(projectRoot, MOFLO_DIR, 'patterns-hash.txt');
 
 const args = process.argv.slice(2);
 const force = args.includes('--force');

package/bin/index-tests.mjs

@@ -28,6 +28,7 @@ import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
 import { execSync, execFileSync, spawn } from 'child_process';
 import { mofloResolveURL } from './lib/moflo-resolve.mjs';
+import { memoryDbPath, MOFLO_DIR } from './lib/moflo-paths.mjs';
 const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -44,8 +45,8 @@ function findProjectRoot() {
 
 const projectRoot = findProjectRoot();
 const NAMESPACE = 'tests';
-const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
-const HASH_CACHE_PATH = resolve(projectRoot, '.swarm/tests-hash.txt');
+const DB_PATH = memoryDbPath(projectRoot);
+const HASH_CACHE_PATH = resolve(projectRoot, MOFLO_DIR, 'tests-hash.txt');
 
 // Parse args
 const args = process.argv.slice(2);

package/bin/lib/moflo-paths.mjs

@@ -1,5 +1,5 @@
 /**
- * Pure-JS counterpart to src/cli/services/moflo-paths.ts (#699).
+ * Pure-JS counterpart to src/cli/services/moflo-paths.ts (#699, #727).
  *
  * Lives in bin/lib because session-start-launcher.mjs and other bin/ scripts
  * run before any TS compilation has happened — they can't import the .ts
@@ -8,11 +8,30 @@
  * launcher path. Algorithm parity is enforced by the parity case in
  * src/cli/__tests__/services/moflo-paths-migration.test.ts.
  */
-import { existsSync, readdirSync, renameSync, rmdirSync } from 'node:fs';
-import { join } from 'node:path';
+import {
+  closeSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readSync,
+  readdirSync,
+  renameSync,
+  rmdirSync,
+  statSync,
+  unlinkSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
 
 export const MOFLO_DIR = '.moflo';
+export const MEMORY_DB_FILE = 'moflo.db';
+export const HNSW_INDEX_FILE = 'hnsw.index';
+
 export const LEGACY_CLAUDE_FLOW_DIR = '.claude-flow';
+export const LEGACY_SWARM_DIR = '.swarm';
+export const LEGACY_MEMORY_DB_FILE = 'memory.db';
+export const LEGACY_MEMORY_DB_BAK_SUFFIX = '.bak';
 
 export function mofloDir(projectRoot) {
   return join(projectRoot, MOFLO_DIR);
@@ -22,6 +41,35 @@ export function legacyClaudeFlowDir(projectRoot) {
   return join(projectRoot, LEGACY_CLAUDE_FLOW_DIR);
 }
 
+export function memoryDbPath(projectRoot) {
+  return join(projectRoot, MOFLO_DIR, MEMORY_DB_FILE);
+}
+
+export function hnswIndexPath(projectRoot) {
+  return join(projectRoot, MOFLO_DIR, HNSW_INDEX_FILE);
+}
+
+export function legacyMemoryDbPath(projectRoot) {
+  return join(projectRoot, LEGACY_SWARM_DIR, LEGACY_MEMORY_DB_FILE);
+}
+
+export function legacyHnswIndexPath(projectRoot) {
+  return join(projectRoot, LEGACY_SWARM_DIR, HNSW_INDEX_FILE);
+}
+
+export function legacyMemoryDbBakPath(projectRoot) {
+  return join(projectRoot, LEGACY_SWARM_DIR, `${LEGACY_MEMORY_DB_FILE}${LEGACY_MEMORY_DB_BAK_SUFFIX}`);
+}
+
+export function memoryDbCandidatePaths(projectRoot) {
+  return [
+    memoryDbPath(projectRoot),
+    legacyMemoryDbPath(projectRoot),
+    join(projectRoot, 'data', LEGACY_MEMORY_DB_FILE),
+    join(projectRoot, '.claude', LEGACY_MEMORY_DB_FILE),
+  ];
+}
+
 /**
  * One-time migration of `.claude-flow/` → `.moflo/`. Idempotent — safe to call
  * on every session start. See moflo-paths.ts for the full contract.
@@ -66,3 +114,106 @@ export function migrateClaudeFlowToMoflo(projectRoot) {
 
   return moved > 0 ? { migrated: true } : { migrated: false, reason: 'merged-nothing' };
 }
+
+const SQLITE_MAGIC_HEADER = Buffer.from('SQLite format 3\0', 'utf8');
+
+function looksLikeSqliteFile(filePath) {
+  let fd = null;
+  try {
+    fd = openSync(filePath, 'r');
+    const buf = Buffer.alloc(SQLITE_MAGIC_HEADER.length);
+    const read = readSync(fd, buf, 0, buf.length, 0);
+    if (read < SQLITE_MAGIC_HEADER.length) return false;
+    return buf.equals(SQLITE_MAGIC_HEADER);
+  } catch {
+    return false;
+  } finally {
+    if (fd !== null) try { closeSync(fd); } catch { /* non-fatal */ }
+  }
+}
+
+function verifyByteEqual(srcPath, dstPath) {
+  try {
+    const srcStat = statSync(srcPath);
+    const dstStat = statSync(dstPath);
+    if (srcStat.size !== dstStat.size) return false;
+    const srcBuf = readFileSync(srcPath);
+    const dstBuf = readFileSync(dstPath);
+    return srcBuf.equals(dstBuf);
+  } catch {
+    return false;
+  }
+}
+
+function tryUnlink(filePath) {
+  try { unlinkSync(filePath); } catch { /* non-fatal */ }
+}
+
+function migrateHnswIndex(projectRoot) {
+  const src = legacyHnswIndexPath(projectRoot);
+  const dst = hnswIndexPath(projectRoot);
+
+  if (!existsSync(src)) return false;
+  if (existsSync(dst)) return false;
+
+  try {
+    mkdirSync(dirname(dst), { recursive: true });
+    copyFileSync(src, dst);
+  } catch {
+    tryUnlink(dst);
+    return false;
+  }
+
+  if (!verifyByteEqual(src, dst)) {
+    tryUnlink(dst);
+    return false;
+  }
+
+  tryUnlink(src);
+  return true;
+}
+
+/**
+ * One-time relocation of memory DB from `.swarm/memory.db` → `.moflo/moflo.db`
+ * (story #727). Idempotent. See moflo-paths.ts for the full contract and the
+ * SQLite-header / byte-equal verification rationale.
+ *
+ * MUST run before any long-lived sql.js consumer (MCP server, daemon) opens
+ * the DB — sql.js dumps the whole snapshot on every flush and would clobber
+ * the relocated file. Launcher section 0b is the safe boundary.
+ */
+export function migrateMemoryDbToMoflo(projectRoot) {
+  const target = memoryDbPath(projectRoot);
+  if (existsSync(target)) return { migrated: false, reason: 'target-exists' };
+
+  const source = legacyMemoryDbPath(projectRoot);
+  if (!existsSync(source)) return { migrated: false, reason: 'no-legacy' };
+
+  try {
+    mkdirSync(dirname(target), { recursive: true });
+  } catch {
+    return { migrated: false, reason: 'copy-failed' };
+  }
+
+  try {
+    copyFileSync(source, target);
+  } catch {
+    tryUnlink(target);
+    return { migrated: false, reason: 'copy-failed' };
+  }
+
+  if (!verifyByteEqual(source, target) || !looksLikeSqliteFile(target)) {
+    tryUnlink(target);
+    return { migrated: false, reason: 'verify-failed' };
+  }
+
+  const hnswMoved = migrateHnswIndex(projectRoot);
+
+  try {
+    renameSync(source, legacyMemoryDbBakPath(projectRoot));
+  } catch {
+    return { migrated: true, reason: 'rename-failed', hnswMoved };
+  }
+
+  return { migrated: true, hnswMoved };
+}

package/bin/semantic-search.mjs

@@ -20,6 +20,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { mofloResolveURL, mofloInternalURL } from './lib/moflo-resolve.mjs';
+import { memoryDbPath } from './lib/moflo-paths.mjs';
 const initSqlJs = (await import(mofloResolveURL('sql.js'))).default;
 const FASTEMBED_INLINE = 'dist/src/cli/embeddings/fastembed-inline/index.js';
 
@@ -34,7 +35,7 @@ function findProjectRoot() {
 }
 
 const projectRoot = findProjectRoot();
-const DB_PATH = resolve(projectRoot, '.swarm/memory.db');
+const DB_PATH = memoryDbPath(projectRoot);
 
 const EMBEDDING_MODEL = 'fast-all-MiniLM-L6-v2';
 const EMBEDDING_DIMS = 384;

package/bin/session-start-launcher.mjs

@@ -11,7 +11,7 @@ import { spawn } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, copyFileSync, unlinkSync, readdirSync, mkdirSync, statSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { migrateClaudeFlowToMoflo } from './lib/moflo-paths.mjs';
+import { migrateClaudeFlowToMoflo, migrateMemoryDbToMoflo } from './lib/moflo-paths.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -72,6 +72,25 @@ try {
   // again next session. Better to keep launching than to block on it.
 }
 
+// ── 0b. LEGACY memory DB relocation (#727) ──────────────────────────────────
+// Run BEFORE long-lived sql.js consumers (MCP server, daemon) — see the
+// `migrateMemoryDbToMoflo` JSDoc for the copy-verify-delete contract and
+// the sql.js write-back hazard.
+try {
+  const dbMigration = migrateMemoryDbToMoflo(projectRoot);
+  if (dbMigration?.migrated) {
+    const detail = dbMigration.hnswMoved
+      ? '.swarm/memory.db → .moflo/moflo.db (with hnsw.index)'
+      : '.swarm/memory.db → .moflo/moflo.db';
+    emitMutation('relocated memory db', detail);
+    if (dbMigration.reason === 'rename-failed') {
+      emitMutation('legacy .swarm/memory.db remains', 'rename to .bak failed — flo doctor will warn');
+    }
+  }
+} catch {
+  // Non-fatal — failed migration leaves both DBs in place; next session retries.
+}
+
 // ── 1. Helper: fire-and-forget a background process ─────────────────────────
 function fireAndForget(cmd, args, label) {
   try {

package/dist/src/cli/commands/doctor-embedding-hygiene.js

@@ -23,9 +23,9 @@
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { existsSync } from 'fs';
-import { join } from 'path';
 import { CANONICAL_EMBEDDING_MODEL } from '../embeddings/migration/types.js';
 import { mofloImport } from '../services/moflo-require.js';
+import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
 /**
  * Known neural-model labels that all share the all-MiniLM-L6-v2 384-dim
  * vector space. The Story-2 migration retags any of these to the
@@ -124,16 +124,7 @@ export async function checkEmbeddingHygiene() {
     };
 }
 function resolveMemoryDb() {
-    const candidates = [
-        join(process.cwd(), '.swarm', 'memory.db'),
-        join(process.cwd(), '.moflo', 'memory.db'),
-        join(process.cwd(), 'data', 'memory.db'),
-    ];
-    for (const p of candidates) {
-        if (existsSync(p))
-            return p;
-    }
-    return null;
+    return memoryDbCandidatePaths(process.cwd()).find((p) => existsSync(p)) ?? null;
 }
 async function loadModelGroups(dbPath) {
     const fs = await import('fs');

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

@@ -16,6 +16,7 @@ import { getDaemonLockHolder, releaseDaemonLock, isDaemonProcess } from '../serv
 import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkMofloDbBridge, getMofloRoot, } from './doctor-checks-deep.js';
 import { checkEmbeddingHygiene } from './doctor-embedding-hygiene.js';
 import { repairHookWiring } from '../services/hook-wiring.js';
+import { legacyMemoryDbPath, memoryDbCandidatePaths, memoryDbPath, } from '../services/moflo-paths.js';
 // Promisified exec with proper shell and env inheritance for cross-platform support
 const execAsync = promisify(exec);
 /**
@@ -168,22 +169,33 @@ async function checkDaemonStatus() {
 }
 // Check memory database
 async function checkMemoryDatabase() {
-    const dbPaths = [
-        '.moflo/memory.db',
-        '.swarm/memory.db',
-        'data/memory.db'
-    ];
-    for (const dbPath of dbPaths) {
-        if (existsSync(dbPath)) {
-            try {
-                const stats = statSync(dbPath);
-                const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-                return { name: 'Memory Database', status: 'pass', message: `${dbPath} (${sizeMB} MB)` };
-            }
-            catch {
-                return { name: 'Memory Database', status: 'warn', message: `${dbPath} (unable to stat)` };
+    const root = process.cwd();
+    const canonical = memoryDbPath(root);
+    for (const dbPath of memoryDbCandidatePaths(root)) {
+        let stats;
+        try {
+            stats = statSync(dbPath);
+        }
+        catch {
+            continue;
+        }
+        const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+        if (dbPath === canonical) {
+            let message = `.moflo/moflo.db (${sizeMB} MB)`;
+            // Unfinished migration tail: source still present means the launcher's
+            // rename-to-.bak step failed (Windows lock most often). Flag so the user
+            // knows to clear the stale source.
+            if (existsSync(legacyMemoryDbPath(root))) {
+                message += ' — legacy .swarm/memory.db still present (delete it after confirming canonical is healthy)';
             }
+            return { name: 'Memory Database', status: 'pass', message };
         }
+        return {
+            name: 'Memory Database',
+            status: 'warn',
+            message: `${dbPath} (${sizeMB} MB) — legacy location, will migrate to .moflo/moflo.db on next session start`,
+            fix: 'restart claude code session',
+        };
     }
     return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
 }
@@ -474,12 +486,7 @@ const VECTOR_STATS_SKEW_WARN_THRESHOLD = 0.2;
 // Check embeddings / vector index health.
 // Exported so the #639 stale-cache regression test can invoke it directly.
 export async function checkEmbeddings() {
-    const dbPaths = [
-        join(process.cwd(), '.swarm', 'memory.db'),
-        join(process.cwd(), '.moflo', 'memory.db'),
-        join(process.cwd(), 'data', 'memory.db'),
-    ];
-    const liveDbPath = dbPaths.find((p) => existsSync(p));
+    const liveDbPath = memoryDbCandidatePaths(process.cwd()).find((p) => existsSync(p));
     // 1. Fast path: read cached vector-stats.json if available
     const statsPath = join(process.cwd(), '.moflo', 'vector-stats.json');
     try {

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

@@ -15,7 +15,9 @@
 import { output } from '../output.js';
 import { mofloImport } from '../services/moflo-require.js';
 import { runEmbeddingsMigrationIfNeeded } from '../services/embeddings-migration.js';
+import { memoryDbPath, MEMORY_DB_FILE, MOFLO_DIR } from '../services/moflo-paths.js';
 import * as embeddings from '../embeddings/index.js';
+const DEFAULT_DB_PATH_FLAG = `${MOFLO_DIR}/${MEMORY_DB_FILE}`;
 // Generate subcommand - REAL implementation
 const generateCommand = {
     name: 'generate',
@@ -96,7 +98,7 @@ const searchCommand = {
         { name: 'collection', short: 'c', type: 'string', description: 'Namespace to search', default: 'default' },
         { name: 'limit', short: 'l', type: 'number', description: 'Max results', default: '10' },
         { name: 'threshold', short: 't', type: 'number', description: 'Similarity threshold (0-1)', default: '0.5' },
-        { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
+        { name: 'db-path', type: 'string', description: 'Database path', default: DEFAULT_DB_PATH_FLAG },
     ],
     examples: [
         { command: 'claude-flow embeddings search -q "error handling"', description: 'Search for similar' },
@@ -107,7 +109,7 @@ const searchCommand = {
         const namespace = ctx.flags.collection || 'default';
         const limit = parseInt(ctx.flags.limit || '10', 10);
         const threshold = parseFloat(ctx.flags.threshold || '0.5');
-        const dbPath = ctx.flags['db-path'] || '.swarm/memory.db';
+        const dbPath = ctx.flags['db-path'] || memoryDbPath(process.cwd());
         if (!query) {
             output.printError('Query is required');
             return { success: false, exitCode: 1 };
@@ -347,7 +349,7 @@ const collectionsCommand = {
     options: [
         { name: 'action', short: 'a', type: 'string', description: 'Action: list, stats', default: 'list' },
         { name: 'name', short: 'n', type: 'string', description: 'Namespace name' },
-        { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
+        { name: 'db-path', type: 'string', description: 'Database path', default: DEFAULT_DB_PATH_FLAG },
     ],
     examples: [
         { command: 'claude-flow embeddings collections', description: 'List collections' },
@@ -355,7 +357,7 @@ const collectionsCommand = {
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
-        const dbPath = ctx.flags['db-path'] || '.swarm/memory.db';
+        const dbPath = ctx.flags['db-path'] || memoryDbPath(process.cwd());
         output.writeln();
         output.writeln(output.bold('Embedding Collections (Namespaces)'));
         output.writeln(output.dim('─'.repeat(60)));
@@ -1489,16 +1491,16 @@ const migrateCommand = {
     name: 'migrate',
     description: 'Re-embed existing vectors using the current neural model (runs automatically on session start if needed)',
     options: [
-        { name: 'db', short: 'd', type: 'string', description: 'Path to memory DB', default: '.swarm/memory.db' },
+        { name: 'db', short: 'd', type: 'string', description: 'Path to memory DB', default: DEFAULT_DB_PATH_FLAG },
         { name: 'batch-size', short: 'b', type: 'number', description: 'Batch size', default: '128' },
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output', default: 'false' },
     ],
     examples: [
-        { command: 'claude-flow embeddings migrate', description: 'Migrate .swarm/memory.db to current version' },
+        { command: 'claude-flow embeddings migrate', description: `Migrate ${DEFAULT_DB_PATH_FLAG} to current version` },
         { command: 'claude-flow embeddings migrate -d .custom/mem.db', description: 'Migrate a custom DB' },
     ],
     action: async (ctx) => {
-        const dbPath = ctx.flags.db || '.swarm/memory.db';
+        const dbPath = ctx.flags.db || memoryDbPath(process.cwd());
         try {
             const ran = await runEmbeddingsMigrationIfNeeded({ dbPath });
             return { success: true, data: { ran } };

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

@@ -7,6 +7,7 @@ import { formatStatus } from '../services/cli-formatters.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { storeCommand } from './transfer-store.js';
+import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
 // Hook types
 const HOOK_TYPES = [
     { value: 'pre-edit', label: 'Pre-Edit', hint: 'Get context before editing files' },
@@ -2544,10 +2545,7 @@ const statuslineCommand = {
         const { execSync } = await import('child_process');
         // Get learning stats from memory database
         function getLearningStats() {
-            const memoryPaths = [
-                path.join(process.cwd(), '.swarm', 'memory.db'),
-                path.join(process.cwd(), '.claude', 'memory.db'),
-            ];
+            const memoryPaths = memoryDbCandidatePaths(process.cwd());
             let patterns = 0;
             let sessions = 0;
             let trajectories = 0;
@@ -2798,12 +2796,9 @@ const statuslineCommand = {
         }
         // Get AgentDB stats (matching .claude/helpers/statusline.cjs paths)
         const agentdbStats = { vectorCount: 0, dbSizeKB: 0, hasHnsw: false };
-        // Check for direct database files first
+        // Check for direct database files first. Canonical first, legacies after.
         const dbPaths = [
-            path.join(process.cwd(), '.swarm', 'memory.db'),
-            path.join(process.cwd(), '.moflo', 'memory.db'),
-            path.join(process.cwd(), '.claude', 'memory.db'),
-            path.join(process.cwd(), 'data', 'memory.db'),
+            ...memoryDbCandidatePaths(process.cwd()),
             path.join(process.cwd(), 'memory.db'),
             path.join(process.cwd(), '.agentdb', 'memory.db'),
             path.join(process.cwd(), '.moflo', 'memory', 'agentdb.db'),

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

@@ -7,14 +7,12 @@ import { select, confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
     const swarmDir = path.join(process.cwd(), '.swarm');
     const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
-    const memoryPaths = [
-        path.join(process.cwd(), '.swarm', 'memory.db'),
-        path.join(process.cwd(), '.claude', 'memory.db'),
-    ];
+    const memoryPaths = memoryDbCandidatePaths(process.cwd());
     // Check for active swarm state file
     const swarmStateFile = path.join(swarmDir, 'state.json');
     let swarmState = null;

package/dist/src/cli/embeddings/migration/sqljs-helpers.js

@@ -9,7 +9,7 @@
  *
  *   2. An `embeddings_migration_cursor` table that persists the resume
  *      cursor per-store (so multiple stores sharing a DB file — e.g.
- *      `.swarm/memory.db` with both `memory_entries` and `patterns` —
+ *      `.moflo/moflo.db` with both `memory_entries` and `patterns` —
  *      each get their own row).
  *
  * The helpers are framework-agnostic: they accept a minimal `SqlJsDatabase`

package/dist/src/cli/hooks/reasoningbank/index.js

@@ -14,6 +14,7 @@
  */
 import { EventEmitter } from 'node:events';
 import { TestDeterministicEmbedding } from './__mocks__/test-embedding-service.js';
+import { MEMORY_DB_FILE, MOFLO_DIR } from '../../services/moflo-paths.js';
 // Dynamic imports for optional dependencies
 let MofloDbAdapter = null;
 let HNSWIndex = null;
@@ -28,7 +29,7 @@ const DEFAULT_CONFIG = {
     promotionThreshold: 3,
     qualityThreshold: 0.6,
     dedupThreshold: 0.95,
-    dbPath: '.moflo/memory.db',
+    dbPath: `${MOFLO_DIR}/${MEMORY_DB_FILE}`,
     useMockEmbeddings: false,
 };
 /**

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

@@ -8,6 +8,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as crypto from 'crypto';
 import { atomicWriteFileSync } from '../services/atomic-file-write.js';
+import { legacyMemoryDbPath, memoryDbPath, MOFLO_DIR, } from '../services/moflo-paths.js';
 // When run via npx, CWD may be node_modules/moflo — walk up to find actual project
 let _projectRoot;
 /**
@@ -28,7 +29,10 @@ function getProjectRoot() {
     let dir = process.cwd();
     const root = path.parse(dir).root;
     while (dir !== root) {
-        if (fs.existsSync(path.join(dir, '.swarm', 'memory.db'))) {
+        // `.moflo/moflo.db` is the canonical post-#727 marker. Older consumers
+        // mid-migration may still only have `.swarm/memory.db`; recognise both
+        // so the bridge can find the project root either way.
+        if (fs.existsSync(memoryDbPath(dir)) || fs.existsSync(legacyMemoryDbPath(dir))) {
             _projectRoot = dir;
             return _projectRoot;
         }
@@ -69,22 +73,42 @@ function logBridgeError(context, err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`[moflo] ${context}: ${msg}`);
 }
-function getDbPath(customPath) {
-    const swarmDir = path.resolve(getProjectRoot(), '.swarm');
-    if (!customPath)
-        return path.join(swarmDir, 'memory.db');
+/**
+ * Resolve the on-disk DB path the bridge should read/write.
+ *
+ * Default to `.moflo/moflo.db`, but during the post-#727 migration window —
+ * after a consumer upgrades but before the next session-start launcher fires
+ * — prefer `.swarm/memory.db` if only the legacy file exists. Without this
+ * preference, any CLI command (e.g. `moflo doctor`) that opens the bridge
+ * before the launcher runs would create an empty canonical, defeating the
+ * launcher's `target-exists` short-circuit and stranding the user's data in
+ * `.swarm/memory.db`.
+ *
+ * Exported for test access; production callers go through the no-arg
+ * `getDbPath()` wrapper below.
+ */
+export function resolveBridgeDbPath(root, customPath) {
+    const canonical = memoryDbPath(root);
+    if (!customPath) {
+        if (!fs.existsSync(canonical) && fs.existsSync(legacyMemoryDbPath(root))) {
+            return legacyMemoryDbPath(root);
+        }
+        return canonical;
+    }
     if (customPath === ':memory:')
         return ':memory:';
     const resolved = path.resolve(customPath);
-    const root = getProjectRoot();
     const rel = path.relative(root, resolved);
     // Reject anything that escapes the project root or is an absolute path
     // outside it (path.relative returns an absolute path on different drives).
     if (rel.startsWith('..') || path.isAbsolute(rel)) {
-        return path.join(swarmDir, 'memory.db');
+        return canonical;
     }
     return resolved;
 }
+function getDbPath(customPath) {
+    return resolveBridgeDbPath(getProjectRoot(), customPath);
+}
 export function generateId(prefix) {
     return `${prefix}_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
 }
@@ -163,9 +187,11 @@ export function execRows(db, sql, params) {
  * when the process exits, which breaks store→retrieve across CLI commands.
  */
 export function persistBridgeDb(db, dbPath) {
-    const target = dbPath
-        ? path.resolve(dbPath)
-        : path.join(getProjectRoot(), '.swarm', 'memory.db');
+    // Mirror the read-side resolution so writes land where reads come from.
+    // Important during the migration window (#727): if we read from
+    // `.swarm/memory.db` because the canonical doesn't exist yet, writing back
+    // there keeps the legacy file fresh until the launcher relocates it.
+    const target = dbPath ? path.resolve(dbPath) : getDbPath();
     if (target === ':memory:')
         return;
     try {
@@ -286,19 +312,15 @@ export function writeVectorStatsJson(rootDir, stats) {
     fs.mkdirSync(cacheDir, { recursive: true });
     fs.writeFileSync(path.join(cacheDir, 'vector-stats.json'), JSON.stringify({ ...stats, updatedAt: Date.now() }));
 }
-/** Probe both legacy locations for an HNSW index sidecar file. */
+/** Probe for the HNSW index sidecar at its canonical post-#727 location. */
 function detectHnswIndex(rootDir) {
-    for (const p of [
-        path.join(rootDir, '.swarm', 'hnsw.index'),
-        path.join(rootDir, '.moflo', 'hnsw.index'),
-    ]) {
-        try {
-            fs.statSync(p);
-            return true;
-        }
-        catch { /* nope */ }
+    try {
+        fs.statSync(path.join(rootDir, MOFLO_DIR, 'hnsw.index'));
+        return true;
+    }
+    catch {
+        return false;
     }
-    return false;
 }
 /**
  * Read the existing on-disk vector-stats cache. Returns null when missing

package/dist/src/cli/memory/memory-initializer.js

@@ -17,6 +17,7 @@ import { HnswLite } from './hnsw-lite.js';
 import { EMBEDDING_MODEL_OPT_OUT, getBridgeEmbedder } from './bridge-embedder.js';
 import { toFloat32 } from './controllers/_shared.js';
 import { writeVectorStatsJson } from './bridge-core.js';
+import { MOFLO_DIR, hnswIndexPath, legacyMemoryDbPath, memoryDbPath, } from '../services/moflo-paths.js';
 /**
  * Write vector-stats.json cache for the statusline (no subprocess needed).
  * Called after memory store in the raw-sql.js fallback path. The bridge path
@@ -31,19 +32,13 @@ function writeVectorStatsCache(dbPath, stats) {
         const dbSizeKB = Math.floor(fileStat.size / 1024);
         const { vectorCount, namespaces, missing = 0 } = stats;
         const dbDir = path.dirname(dbPath);
-        const projectDir = path.dirname(dbDir); // .swarm -> project root
+        const projectDir = path.dirname(dbDir); // .moflo (or legacy .swarm) -> project root
         let hasHnsw = false;
-        for (const p of [
-            path.join(dbDir, 'hnsw.index'),
-            path.join(projectDir, '.moflo', 'hnsw.index'),
-        ]) {
-            try {
-                fs.statSync(p);
-                hasHnsw = true;
-                break;
-            }
-            catch { /* nope */ }
+        try {
+            fs.statSync(hnswIndexPath(projectDir));
+            hasHnsw = true;
         }
+        catch { /* nope */ }
         writeVectorStatsJson(projectDir, { vectorCount, missing, dbSizeKB, namespaces, hasHnsw });
     }
     catch { /* Non-fatal */ }
@@ -381,13 +376,13 @@ export async function getHNSWIndex(options) {
     hnswInitializing = true;
     try {
         // Use HnswLite pure TS implementation (no native dependencies).
-        // Persistent storage paths
-        const swarmDir = path.join(process.cwd(), '.swarm');
-        if (!fs.existsSync(swarmDir)) {
-            fs.mkdirSync(swarmDir, { recursive: true });
+        // Persistent storage paths — colocated with the canonical memory DB.
+        const dbPath = options?.dbPath || memoryDbPath(process.cwd());
+        const dbDir = path.dirname(dbPath);
+        if (!fs.existsSync(dbDir)) {
+            fs.mkdirSync(dbDir, { recursive: true });
         }
-        const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
-        const dbPath = options?.dbPath || path.join(swarmDir, 'memory.db');
+        const metadataPath = path.join(dbDir, 'hnsw.metadata.json');
         // Create HnswLite index and wrap it with the expected db interface
         const hnsw = new HnswLite(dimensions, 16, 200, 'cosine');
         const db = {
@@ -478,8 +473,7 @@ function saveHNSWMetadata() {
     if (!hnswIndex?.entries)
         return;
     try {
-        const swarmDir = path.join(process.cwd(), '.swarm');
-        const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
+        const metadataPath = path.join(path.dirname(memoryDbPath(process.cwd())), 'hnsw.metadata.json');
         const metadata = Array.from(hnswIndex.entries.entries());
         fs.writeFileSync(metadataPath, JSON.stringify(metadata));
     }
@@ -893,12 +887,17 @@ export async function ensureSchemaColumns(dbPath) {
  */
 export async function checkAndMigrateLegacy(options) {
     const { dbPath, verbose = false } = options;
-    // Check for legacy locations
+    // Check for legacy locations. `.swarm/memory.db` is the pre-#727 layout
+    // primarily handled by the launcher's copy-verify-delete migration; this
+    // probe still catches consumers whose launcher migration deferred. The
+    // bare `memory.db` and `.claude/memory.db`/`data/memory.db` entries are
+    // older still.
     const legacyPaths = [
+        legacyMemoryDbPath(process.cwd()),
+        path.join(process.cwd(), MOFLO_DIR, 'memory.db'),
         path.join(process.cwd(), 'memory.db'),
-        path.join(process.cwd(), '.claude/memory.db'),
-        path.join(process.cwd(), 'data/memory.db'),
-        path.join(process.cwd(), '.moflo/memory.db')
+        path.join(process.cwd(), '.claude', 'memory.db'),
+        path.join(process.cwd(), 'data', 'memory.db'),
     ];
     for (const legacyPath of legacyPaths) {
         if (fs.existsSync(legacyPath) && legacyPath !== dbPath) {
@@ -983,8 +982,7 @@ async function activateControllerRegistry(dbPath, verbose) {
  */
 export async function initializeMemoryDatabase(options) {
     const { backend = 'hybrid', dbPath: customPath, force = false, verbose = false, migrate = true } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbPath = customPath || memoryDbPath(process.cwd());
     const dbDir = path.dirname(dbPath);
     try {
         // Create directory if needed
@@ -1165,8 +1163,7 @@ export async function initializeMemoryDatabase(options) {
  * Check if memory database is properly initialized
  */
 export async function checkMemoryInitialization(dbPath) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const path_ = dbPath || path.join(swarmDir, 'memory.db');
+    const path_ = dbPath || memoryDbPath(process.cwd());
     if (!fs.existsSync(path_)) {
         return { initialized: false };
     }
@@ -1214,8 +1211,7 @@ export async function checkMemoryInitialization(dbPath) {
  * Reduces confidence of patterns that haven't been used recently
  */
 export async function applyTemporalDecay(dbPath) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const path_ = dbPath || path.join(swarmDir, 'memory.db');
+    const path_ = dbPath || memoryDbPath(process.cwd());
     try {
         const initSqlJs = (await mofloImport('sql.js')).default;
         const SQL = await initSqlJs();
@@ -1579,8 +1575,7 @@ export async function storeEntry(options) {
     }
     // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbPath = customPath || memoryDbPath(process.cwd());
     try {
         if (!fs.existsSync(dbPath)) {
             return { success: false, id: '', error: 'Database not initialized. Run: claude-flow memory init' };
@@ -1718,8 +1713,7 @@ export async function searchEntries(options) {
     }
     // Fallback: raw sql.js
     const { query, namespace = 'default', limit = 10, threshold = 0.3, dbPath: customPath } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbPath = customPath || memoryDbPath(process.cwd());
     const startTime = Date.now();
     try {
         if (!fs.existsSync(dbPath)) {
@@ -1837,8 +1831,7 @@ export async function listEntries(options) {
     }
     // Fallback: raw sql.js
     const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbPath = customPath || memoryDbPath(process.cwd());
     try {
         if (!fs.existsSync(dbPath)) {
             return { success: false, entries: [], total: 0, error: 'Database not found' };
@@ -1906,8 +1899,7 @@ export async function getEntry(options) {
     }
     // Fallback: raw sql.js
     const { key, namespace = 'default', dbPath: customPath } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbPath = customPath || memoryDbPath(process.cwd());
     try {
         if (!fs.existsSync(dbPath)) {
             return { success: false, found: false, error: 'Database not found' };
@@ -1987,8 +1979,7 @@ export async function deleteEntry(options) {
     }
     // Fallback: raw sql.js
     const { key, namespace = 'default', dbPath: customPath } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
+    const dbPath = customPath || memoryDbPath(process.cwd());
     try {
         if (!fs.existsSync(dbPath)) {
             return {
@@ -2065,8 +2056,7 @@ export async function deleteEntry(options) {
  * Returns { namespaces: Record<string, number>, total: number }.
  */
 export async function getNamespaceCounts(dbPath) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const resolvedPath = dbPath || path.join(swarmDir, 'memory.db');
+    const resolvedPath = dbPath || memoryDbPath(process.cwd());
     try {
         if (!fs.existsSync(resolvedPath)) {
             return { namespaces: {}, total: 0 };

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

@@ -197,6 +197,7 @@ export class MemoryMigrator extends EventEmitter {
         // For now, try to load from common paths
         const possiblePaths = [
             './memory/memory-store.json',
+            './.moflo/moflo.db',
             './.swarm/memory.db',
             './memory.json',
         ];

package/dist/src/cli/services/embeddings-migration.js

@@ -1,5 +1,5 @@
 /**
- * Idempotent embeddings-version migration for moflo's memory.db.
+ * Idempotent embeddings-version migration for moflo's memory DB (`.moflo/moflo.db`).
  *
  * Runs the story-2 driver (`runUpgrade`) with the story-3 UX on any DB whose
  * stored `embeddings_version` is below the current runtime version OR whose
@@ -17,6 +17,7 @@
 /* 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';
 // EMBEDDINGS_VERSION is a number constant in a leaf types module — pulling it
 // eagerly is cheap. The heavy imports (fastembed wrapper, upgrade renderer,
 // etc.) stay deferred behind the early returns so session-start stays fast.
@@ -33,7 +34,7 @@ import { CANONICAL_EMBEDDING_MODEL, EMBEDDINGS_VERSION, } from '../embeddings/mi
 export async function runEmbeddingsMigrationIfNeeded(options = {}) {
     const fs = await import('fs');
     const path = await import('path');
-    const dbPath = path.resolve(options.dbPath ?? path.join(process.cwd(), '.swarm', 'memory.db'));
+    const dbPath = path.resolve(options.dbPath ?? memoryDbPath(process.cwd()));
     if (!fs.existsSync(dbPath))
         return false;
     const initSqlJs = (await mofloImport('sql.js'))?.default;
@@ -106,7 +107,7 @@ export async function runEmbeddingsMigrationIfNeeded(options = {}) {
         if (summary.status === 'completed') {
             // `db.export()` returns a Uint8Array; `writeFileSync` accepts it directly,
             // so no Buffer.from() copy. Atomic temp-file + rename so SIGINT mid-write
-            // cannot truncate memory.db — see atomic-file-write.ts.
+            // cannot truncate moflo.db — see atomic-file-write.ts.
             atomicWriteFileSync(dbPath, db.export());
             options.onMigrationComplete?.(summary.totalItemsMigrated);
             return true;

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

@@ -6,16 +6,17 @@
  * promotion, deduplication, and consolidation.
  *
  * Features:
- * - Pattern storage/search with sql.js backend (.swarm/memory.db)
+ * - Pattern storage/search with sql.js 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 { join } from 'path';
+import { dirname } from 'path';
 import { mofloImport } from './moflo-require.js';
 import { atomicWriteFileSync } from './atomic-file-write.js';
+import { memoryDbPath } from './moflo-paths.js';
 import { createNeuralEmbeddingProvider, } from './neural-embedding-provider.js';
 // ============================================================================
 // Configuration
@@ -262,12 +263,9 @@ export class LearningService {
     longTermIndex = new HNSWIndex();
     dirty = false;
     dbPath;
-    dataDir;
     embedderPromise = null;
     constructor(projectRoot, embedder) {
-        const root = projectRoot || process.cwd();
-        this.dataDir = join(root, '.swarm');
-        this.dbPath = join(this.dataDir, 'memory.db');
+        this.dbPath = memoryDbPath(projectRoot || process.cwd());
         if (embedder)
             this.embedderPromise = Promise.resolve(embedder);
     }
@@ -281,8 +279,9 @@ export class LearningService {
     async initialize() {
         if (this.db)
             return;
-        if (!existsSync(this.dataDir)) {
-            mkdirSync(this.dataDir, { recursive: true });
+        const dataDir = dirname(this.dbPath);
+        if (!existsSync(dataDir)) {
+            mkdirSync(dataDir, { recursive: true });
         }
         const SQL = await loadSqlJs();
         if (existsSync(this.dbPath)) {

package/dist/src/cli/services/moflo-paths.js

@@ -1,5 +1,5 @@
 /**
- * MoFlo runtime state directory constants + legacy migration (#699).
+ * MoFlo runtime state directory constants + legacy migrations (#699, #727).
  *
  * MoFlo owns its state under `.moflo/` at the project root. The upstream Ruflo
  * fork used `.claude-flow/`; consumers upgrading from older moflo builds (which
@@ -16,20 +16,66 @@
  * been compiled. The parity test in moflo-paths-migration.test.ts catches
  * algorithm divergence between the two.
  */
-import { existsSync, readdirSync, renameSync, rmdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmdirSync, statSync, unlinkSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
 export const MOFLO_DIR = '.moflo';
+/** Canonical memory DB filename (post-#727). Lives at `<root>/.moflo/moflo.db`. */
+export const MEMORY_DB_FILE = 'moflo.db';
+/** HNSW persisted index sidecar. Lives next to the DB at `<root>/.moflo/hnsw.index`. */
+export const HNSW_INDEX_FILE = 'hnsw.index';
 /**
  * Legacy runtime directory inherited from upstream Ruflo. Only referenced from
  * migration code paths — production code should use {@link MOFLO_DIR}.
  */
 export const LEGACY_CLAUDE_FLOW_DIR = '.claude-flow';
+/** Legacy `.swarm/` directory used by Ruflo + pre-#727 moflo for the memory DB. */
+export const LEGACY_SWARM_DIR = '.swarm';
+/** Legacy memory DB filename — only ever inside `.swarm/`. Pre-#727. */
+export const LEGACY_MEMORY_DB_FILE = 'memory.db';
+/** Suffix appended to `.swarm/memory.db` once migrated, retained one upgrade cycle. */
+export const LEGACY_MEMORY_DB_BAK_SUFFIX = '.bak';
 export function mofloDir(projectRoot) {
     return join(projectRoot, MOFLO_DIR);
 }
 export function legacyClaudeFlowDir(projectRoot) {
     return join(projectRoot, LEGACY_CLAUDE_FLOW_DIR);
 }
+/** Canonical memory DB path: `<root>/.moflo/moflo.db`. */
+export function memoryDbPath(projectRoot) {
+    return join(projectRoot, MOFLO_DIR, MEMORY_DB_FILE);
+}
+/** Canonical HNSW index sidecar path: `<root>/.moflo/hnsw.index`. */
+export function hnswIndexPath(projectRoot) {
+    return join(projectRoot, MOFLO_DIR, HNSW_INDEX_FILE);
+}
+/** Legacy memory DB path: `<root>/.swarm/memory.db`. Migration source only. */
+export function legacyMemoryDbPath(projectRoot) {
+    return join(projectRoot, LEGACY_SWARM_DIR, LEGACY_MEMORY_DB_FILE);
+}
+/** Legacy HNSW index path: `<root>/.swarm/hnsw.index`. Migration source only. */
+export function legacyHnswIndexPath(projectRoot) {
+    return join(projectRoot, LEGACY_SWARM_DIR, HNSW_INDEX_FILE);
+}
+/** Backup sentinel kept for one upgrade cycle: `<root>/.swarm/memory.db.bak`. */
+export function legacyMemoryDbBakPath(projectRoot) {
+    return join(projectRoot, LEGACY_SWARM_DIR, `${LEGACY_MEMORY_DB_FILE}${LEGACY_MEMORY_DB_BAK_SUFFIX}`);
+}
+/**
+ * Memory-DB probe order used by every reader that does best-effort detection
+ * (statusline, doctor, swarm status, hooks aggregator). Canonical first so
+ * the early-break stops at the post-#727 location; legacy paths kept so a
+ * partially-migrated consumer still surfaces a result.
+ *
+ * Keep in sync with the pure-JS twin in `bin/lib/moflo-paths.mjs`.
+ */
+export function memoryDbCandidatePaths(projectRoot) {
+    return [
+        memoryDbPath(projectRoot),
+        legacyMemoryDbPath(projectRoot),
+        join(projectRoot, 'data', LEGACY_MEMORY_DB_FILE),
+        join(projectRoot, '.claude', LEGACY_MEMORY_DB_FILE),
+    ];
+}
 /**
  * One-time migration of `.claude-flow/` → `.moflo/`.
  *
@@ -80,4 +126,134 @@ export function migrateClaudeFlowToMoflo(projectRoot) {
     }
     return moved > 0 ? { migrated: true } : { migrated: false, reason: 'merged-nothing' };
 }
+const SQLITE_MAGIC_HEADER = Buffer.from('SQLite format 3\0', 'utf8');
+function looksLikeSqliteFile(filePath) {
+    let fd = null;
+    try {
+        fd = openSync(filePath, 'r');
+        const buf = Buffer.alloc(SQLITE_MAGIC_HEADER.length);
+        const read = readSync(fd, buf, 0, buf.length, 0);
+        if (read < SQLITE_MAGIC_HEADER.length)
+            return false;
+        return buf.equals(SQLITE_MAGIC_HEADER);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (fd !== null)
+            try {
+                closeSync(fd);
+            }
+            catch { /* non-fatal */ }
+    }
+}
+function verifyByteEqual(srcPath, dstPath) {
+    try {
+        const srcStat = statSync(srcPath);
+        const dstStat = statSync(dstPath);
+        if (srcStat.size !== dstStat.size)
+            return false;
+        const srcBuf = readFileSync(srcPath);
+        const dstBuf = readFileSync(dstPath);
+        return srcBuf.equals(dstBuf);
+    }
+    catch {
+        return false;
+    }
+}
+function tryUnlink(filePath) {
+    try {
+        unlinkSync(filePath);
+    }
+    catch { /* non-fatal */ }
+}
+/**
+ * Move `.swarm/hnsw.index` → `.moflo/hnsw.index` using the same
+ * copy-verify-delete pattern as the DB. Returns true on success, false when
+ * source absent or copy/verify failed (caller treats as best-effort).
+ */
+function migrateHnswIndex(projectRoot) {
+    const src = legacyHnswIndexPath(projectRoot);
+    const dst = hnswIndexPath(projectRoot);
+    if (!existsSync(src))
+        return false;
+    if (existsSync(dst))
+        return false; // already there — leave both alone
+    try {
+        mkdirSync(dirname(dst), { recursive: true });
+        copyFileSync(src, dst);
+    }
+    catch {
+        tryUnlink(dst);
+        return false;
+    }
+    if (!verifyByteEqual(src, dst)) {
+        tryUnlink(dst);
+        return false;
+    }
+    tryUnlink(src); // sidecar can be regenerated; no .bak retention needed
+    return true;
+}
+/**
+ * One-time relocation of the memory DB from the upstream `.swarm/memory.db`
+ * layout to the canonical `.moflo/moflo.db` (story #727).
+ *
+ * Algorithm — copy-verify-delete, never `mv`:
+ *   1. If `.moflo/moflo.db` exists → no-op (`target-exists`).
+ *   2. If `.swarm/memory.db` absent → no-op (`no-legacy`).
+ *   3. Ensure `.moflo/` exists.
+ *   4. `copyFileSync(.swarm/memory.db, .moflo/moflo.db)`.
+ *   5. Verify byte-equal (size + content) AND SQLite header magic.
+ *   6. Move `.swarm/hnsw.index` → `.moflo/hnsw.index` (best-effort).
+ *   7. Rename `.swarm/memory.db` → `.swarm/memory.db.bak` (kept one upgrade cycle).
+ *
+ * Any failure between 4–7 deletes the partial target and returns failure;
+ * next session-start retries.
+ *
+ * MUST run BEFORE any long-lived consumer (MCP server, daemon) opens the DB —
+ * sql.js holds a full snapshot in RAM and would clobber the relocated file
+ * on its next flush. The launcher's section before the fire-and-forget block
+ * is the safe boundary; see feedback memory `feedback_sqljs_writeback_clobber`.
+ *
+ * Idempotent.
+ */
+export function migrateMemoryDbToMoflo(projectRoot) {
+    const target = memoryDbPath(projectRoot);
+    if (existsSync(target))
+        return { migrated: false, reason: 'target-exists' };
+    const source = legacyMemoryDbPath(projectRoot);
+    if (!existsSync(source))
+        return { migrated: false, reason: 'no-legacy' };
+    try {
+        mkdirSync(dirname(target), { recursive: true });
+    }
+    catch {
+        return { migrated: false, reason: 'copy-failed' };
+    }
+    try {
+        copyFileSync(source, target);
+    }
+    catch {
+        tryUnlink(target);
+        return { migrated: false, reason: 'copy-failed' };
+    }
+    if (!verifyByteEqual(source, target) || !looksLikeSqliteFile(target)) {
+        tryUnlink(target);
+        return { migrated: false, reason: 'verify-failed' };
+    }
+    const hnswMoved = migrateHnswIndex(projectRoot);
+    // Final step: retire the source by renaming to .bak. Only after the new
+    // file is verified — never lose data. If this rename fails we leave the
+    // source in place; a stale `.swarm/memory.db` next to a healthy
+    // `.moflo/moflo.db` is harmless (the bridge reads only the new path) and
+    // surfaces as a `flo doctor` warning.
+    try {
+        renameSync(source, legacyMemoryDbBakPath(projectRoot));
+    }
+    catch {
+        return { migrated: true, reason: 'rename-failed', hnswMoved };
+    }
+    return { migrated: true, hnswMoved };
+}
 //# sourceMappingURL=moflo-paths.js.map

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.0-rc.1';
+export const VERSION = '4.9.0-rc.2';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.9.0-rc.1",
+  "version": "4.9.0-rc.2",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -78,7 +78,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.8.87",
+    "moflo": "^4.9.0-rc.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"