moflo 4.9.1 → 4.9.3

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

@@ -2582,11 +2582,68 @@ const refreshCommand = {
         return { success: true };
     },
 };
+// Manual recovery for legacy DBs the launcher's auto cherry-pick can't reach
+// — schema mismatches that made the auto-run skip, an even older legacy DB
+// the candidate list doesn't include, or a friend's exported DB.
+const restoreLearningsCommand = {
+    name: 'restore-learnings',
+    description: 'Cherry-pick learnings/knowledge entries from a legacy DB into .moflo/moflo.db',
+    options: [
+        {
+            name: 'from',
+            description: 'Path to the legacy DB to read from (e.g. .swarm/memory.db)',
+            type: 'string',
+            required: true,
+        },
+    ],
+    examples: [
+        { command: 'flo memory restore-learnings --from .swarm/memory.db', description: 'Recover from a legacy memory DB' },
+        { command: 'flo memory restore-learnings --from .swarm/memory.db.bak', description: 'Recover from a post-upgrade .bak' },
+    ],
+    action: async (ctx) => {
+        const from = ctx.flags.from;
+        if (!from) {
+            output.printError('Source DB path is required. Use --from <path>');
+            return { success: false, exitCode: 1 };
+        }
+        const sourcePath = pathModule.resolve(from);
+        if (!fs.existsSync(sourcePath)) {
+            output.printError(`Source DB not found: ${sourcePath}`);
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const { cherryPickLearningsFromLegacy, CHERRY_PICK_SKIP_REASONS } = await import('../services/cherry-pick-learnings.js');
+            const result = await cherryPickLearningsFromLegacy({
+                projectRoot: process.cwd(),
+                legacyPaths: [sourcePath],
+            });
+            const report = result.sources[0];
+            if (report?.reason === CHERRY_PICK_SKIP_REASONS.SCHEMA_MISMATCH) {
+                output.printWarning(`Source DB has no memory_entries table — nothing to copy: ${sourcePath}`);
+                return { success: true, data: result };
+            }
+            if (report?.reason === CHERRY_PICK_SKIP_REASONS.OPEN_FAILED) {
+                output.printError(`Could not open source DB: ${sourcePath}`);
+                return { success: false, exitCode: 1, data: result };
+            }
+            output.printSuccess(`Cherry-picked ${result.copied} of ${result.considered} learning/knowledge entries from ${sourcePath}`);
+            if (result.copied < result.considered) {
+                output.printInfo(`${result.considered - result.copied} duplicate row${result.considered - result.copied === 1 ? '' : 's'} skipped (INSERT OR IGNORE)`);
+            }
+            output.printInfo(`Target: ${result.target}`);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`restore-learnings failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
 // Main memory command
 export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
-    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, indexGuidanceCommand, rebuildIndexCommand, codeMapCommand, refreshCommand],
+    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, indexGuidanceCommand, rebuildIndexCommand, codeMapCommand, refreshCommand, restoreLearningsCommand],
     options: [],
     examples: [
         { command: 'claude-flow memory store -k "key" -v "value"', description: 'Store data' },
@@ -2616,7 +2673,8 @@ export const memoryCommand = {
             `${output.highlight('index-guidance')}  - Index .claude/guidance/ files with RAG segments`,
             `${output.highlight('rebuild-index')}   - Regenerate embeddings for memory entries`,
             `${output.highlight('code-map')}        - Generate structural code map`,
-            `${output.highlight('refresh')}         - Reindex all content, rebuild embeddings, cleanup, and vacuum`
+            `${output.highlight('refresh')}         - Reindex all content, rebuild embeddings, cleanup, and vacuum`,
+            `${output.highlight('restore-learnings')} - Cherry-pick learnings/knowledge from a legacy DB`
         ]);
         return { success: true };
     }

package/dist/src/cli/services/cherry-pick-learnings.js

@@ -0,0 +1,209 @@
+/**
+ * Selective cherry-pick of durable memory rows on upgrade (#851).
+ *
+ * Replaces the full-DB byte-copy migration that epic #726 / story #727
+ * shipped (`migrateMemoryDbToMoflo`). That approach moved the entire 50+ MB
+ * of accumulated memory state across paths, then left the daemon writing to
+ * stale paths from its in-memory module cache. The user-visible result was
+ * "git went haywire" — see docs/moflo-4.9.1-upgrade-experience-2026-05-02.md.
+ *
+ * Almost all DB content is derived (code-map, embeddings, patterns, guidance
+ * chunks) and rebuilds on demand from the indexers. Only the `learnings`
+ * and `knowledge` namespaces are user-authored and worth carrying forward
+ * across upgrades. Everything else is regenerated cheaply.
+ *
+ * Algorithm:
+ *   1. Probe legacy DB candidates (`.swarm/memory.db.bak`, `.swarm/memory.db`,
+ *      etc.) read-only — sources are NEVER mutated.
+ *   2. Ensure the target `.moflo/moflo.db` exists with V3 schema (idempotent
+ *      `CREATE TABLE IF NOT EXISTS`).
+ *   3. `SELECT … WHERE namespace IN ('learnings', 'knowledge')` from each
+ *      legacy source.
+ *   4. `INSERT OR IGNORE INTO memory_entries` keyed on the existing
+ *      `UNIQUE(namespace, key)` constraint — duplicates skip silently, which
+ *      is what makes a re-run of an interrupted migration safe.
+ *   5. `atomicWriteFileSync` the target so a SIGINT mid-flush can't truncate.
+ *
+ * Caller (the launcher) is responsible for stopping the daemon before this
+ * runs — sql.js holds a full snapshot in memory and a concurrent flush from
+ * a stale daemon would clobber the cherry-picked rows.
+ *
+ * @module cli/services/cherry-pick-learnings
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as fs from 'fs';
+import * as path from 'path';
+import { mofloImport } from './moflo-require.js';
+import { atomicWriteFileSync } from './atomic-file-write.js';
+import { legacyMemoryDbBakPath, memoryDbCandidatePaths, memoryDbPath, } from './moflo-paths.js';
+import { MEMORY_SCHEMA_V3 } from '../memory/memory-initializer.js';
+/** Namespaces preserved across upgrades. Everything else is derived. */
+export const DURABLE_NAMESPACES = ['learnings', 'knowledge'];
+/**
+ * Reasons a single source contributed zero rows. Exported so callers can
+ * branch on the cause without duplicating string literals.
+ */
+export const CHERRY_PICK_SKIP_REASONS = {
+    OPEN_FAILED: 'open-failed',
+    SCHEMA_MISMATCH: 'schema-mismatch',
+    NO_ROWS: 'no-rows',
+    SELF_REFERENCE: 'self-reference',
+};
+/**
+ * Composed off `memoryDbCandidatePaths` so any future addition there
+ * (statusline, doctor, etc. all share that probe order) automatically
+ * extends the cherry-pick. The `.bak` path is added at highest priority
+ * because it's the post-#727 migration backup and ranks above the live
+ * legacy file. The canonical `.moflo/moflo.db` is dropped — the
+ * self-reference guard would skip it anyway, and including it would just
+ * confuse the report.
+ */
+function defaultLegacyCandidates(projectRoot) {
+    const canonical = memoryDbPath(projectRoot);
+    const tail = memoryDbCandidatePaths(projectRoot).filter((p) => p !== canonical);
+    return [legacyMemoryDbBakPath(projectRoot), ...tail];
+}
+/**
+ * Cherry-pick durable memory rows from any legacy DBs into `.moflo/moflo.db`.
+ *
+ * Returns a report — never throws on per-source failures. The caller (launcher)
+ * surfaces the count via `emitMutation`; a missing source / schema mismatch /
+ * locked file is recorded in `sources[].reason` and the upgrade continues.
+ *
+ * Hard failures (sql.js unavailable, target write failure) propagate so the
+ * launcher can choose to swallow + retry next session-start.
+ */
+export async function cherryPickLearningsFromLegacy(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const target = path.resolve(options.toPath ?? memoryDbPath(projectRoot));
+    const namespaces = options.namespaces ?? DURABLE_NAMESPACES;
+    const legacyPaths = (options.legacyPaths ?? defaultLegacyCandidates(projectRoot)).map((p) => path.resolve(p));
+    const result = {
+        copied: 0,
+        considered: 0,
+        sources: [],
+        target,
+    };
+    const initSqlJs = (await mofloImport('sql.js'))?.default;
+    if (!initSqlJs)
+        return result;
+    const SQL = (await initSqlJs());
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const targetExists = fs.existsSync(target);
+    const targetDb = targetExists
+        ? new SQL.Database(fs.readFileSync(target))
+        : new SQL.Database();
+    let insertStmt = null;
+    try {
+        targetDb.run(MEMORY_SCHEMA_V3);
+        const placeholders = namespaces.map(() => '?').join(',');
+        const selectSql = `SELECT id, key, namespace, content, type, embedding, embedding_model, ` +
+            `embedding_dimensions, tags, metadata, owner_id, created_at, updated_at, status ` +
+            `FROM memory_entries WHERE namespace IN (${placeholders})`;
+        // Hoisted prepare — avoids re-parsing the SQL inside sql.js for every
+        // INSERT. Matters for legacy DBs with hundreds of learnings rows.
+        insertStmt = targetDb.prepare(`INSERT OR IGNORE INTO memory_entries ` +
+            `(id, key, namespace, content, type, embedding, embedding_model, ` +
+            ` embedding_dimensions, tags, metadata, owner_id, created_at, updated_at, status) ` +
+            `VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const sourcePath of legacyPaths) {
+            if (sourcePath === target) {
+                result.sources.push({
+                    path: sourcePath,
+                    rowsRead: 0,
+                    rowsInserted: 0,
+                    reason: CHERRY_PICK_SKIP_REASONS.SELF_REFERENCE,
+                });
+                continue;
+            }
+            if (!fs.existsSync(sourcePath))
+                continue;
+            const report = readAndInsert(SQL, sourcePath, targetDb, insertStmt, selectSql, namespaces);
+            result.sources.push(report);
+            result.copied += report.rowsInserted;
+            result.considered += report.rowsRead;
+        }
+        // Skip the atomic write when there's nothing to persist:
+        //  - copied=0 + target didn't exist → don't materialize an empty DB
+        //    (the regular initializer creates it on first real write).
+        //  - copied=0 + target already existed → no diff, nothing to flush.
+        if (result.copied > 0) {
+            atomicWriteFileSync(target, Buffer.from(targetDb.export()));
+        }
+    }
+    finally {
+        if (insertStmt) {
+            try {
+                insertStmt.free();
+            }
+            catch { /* best-effort cleanup */ }
+        }
+        targetDb.close();
+    }
+    return result;
+}
+function readAndInsert(SQL, sourcePath, targetDb, insertStmt, selectSql, namespaces) {
+    let sourceDb;
+    try {
+        sourceDb = new SQL.Database(fs.readFileSync(sourcePath));
+    }
+    catch {
+        return {
+            path: sourcePath,
+            rowsRead: 0,
+            rowsInserted: 0,
+            reason: CHERRY_PICK_SKIP_REASONS.OPEN_FAILED,
+        };
+    }
+    try {
+        // Older / unrelated DBs may not have memory_entries.
+        const probe = sourceDb.exec(`SELECT name FROM sqlite_master WHERE type='table' AND name='memory_entries' LIMIT 1`);
+        if (!probe[0]?.values?.[0]) {
+            return {
+                path: sourcePath,
+                rowsRead: 0,
+                rowsInserted: 0,
+                reason: CHERRY_PICK_SKIP_REASONS.SCHEMA_MISMATCH,
+            };
+        }
+        let rowsRead = 0;
+        let rowsInserted = 0;
+        const selectStmt = sourceDb.prepare(selectSql);
+        selectStmt.bind(namespaces.slice());
+        while (selectStmt.step()) {
+            rowsRead++;
+            const row = selectStmt.getAsObject();
+            insertStmt.bind([
+                row.id,
+                row.key,
+                row.namespace,
+                row.content,
+                row.type ?? 'semantic',
+                row.embedding ?? null,
+                row.embedding_model ?? null,
+                row.embedding_dimensions ?? null,
+                row.tags ?? null,
+                row.metadata ?? null,
+                row.owner_id ?? null,
+                row.created_at ?? null,
+                row.updated_at ?? null,
+                row.status ?? 'active',
+            ]);
+            insertStmt.step();
+            if (targetDb.getRowsModified() > 0)
+                rowsInserted++;
+            insertStmt.reset();
+        }
+        selectStmt.free();
+        return {
+            path: sourcePath,
+            rowsRead,
+            rowsInserted,
+            reason: rowsRead === 0 ? CHERRY_PICK_SKIP_REASONS.NO_ROWS : undefined,
+        };
+    }
+    finally {
+        sourceDb.close();
+    }
+}
+//# sourceMappingURL=cherry-pick-learnings.js.map

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

@@ -1,24 +1,25 @@
 /**
- * MoFlo runtime state directory constants + legacy migrations (#699, #727).
+ * MoFlo runtime state directory constants.
  *
  * MoFlo owns its state under `.moflo/` at the project root. The upstream Ruflo
- * fork used `.claude-flow/`; consumers upgrading from older moflo builds (which
- * inherited that path) get a one-time auto-migration so they don't lose claim
- * files, daemon state, metrics, etc.
+ * fork used `.claude-flow/`; both legacy locations are still recognized as
+ * read-only sources for the version-bump-gated cherry-pick (#851) but are
+ * never relocated or renamed automatically — leaving them in place gives
+ * consumers a recovery source and avoids the failure modes that motivated
+ * the issue (silent migrations, daemon-held stale paths, .gitignore deletion).
  *
  * Anything that touches a runtime state path under the project root must
  * compose it from `MOFLO_DIR`. Plain string literals like `'.moflo'` are
  * tolerated where a constant import is awkward (shell templates, tests) but
  * production code is checked by `published-package-drift-guard.test.ts`.
  *
- * The pure-JS twin at `bin/lib/moflo-paths.mjs` mirrors the algorithm so
- * `bin/session-start-launcher.mjs` can run the migration before any TS has
- * been compiled. The parity test in moflo-paths-migration.test.ts catches
- * algorithm divergence between the two.
+ * The pure-JS twin at `bin/lib/moflo-paths.mjs` mirrors these constants so
+ * `bin/session-start-launcher.mjs` can resolve paths before any TS is
+ * compiled. The cherry-pick logic itself lives in
+ * `cli/services/cherry-pick-learnings.ts` and is dynamically imported from
+ * the compiled `dist/` by the launcher.
  */
-import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmdirSync, statSync, unlinkSync, } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { atomicWriteFileSync } from '../shared/utils/atomic-file-write.js';
+import { 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';
@@ -77,249 +78,4 @@ export function memoryDbCandidatePaths(projectRoot) {
         join(projectRoot, '.claude', LEGACY_MEMORY_DB_FILE),
     ];
 }
-/**
- * One-time migration of `.claude-flow/` → `.moflo/`.
- *
- * - Legacy missing → no-op (the steady state after first run).
- * - Legacy present + target missing → atomic rename (preserves mtimes).
- * - Both present → merge: target wins on collision, leaving the colliding
- *   entry behind in legacy/ so the launcher can warn and a future run can
- *   retry. Drops the legacy dir if everything moved cleanly.
- *
- * When the models cache moves (legacy `.claude-flow/models/` lands at
- * `.moflo/models/`), `.moflo/embeddings.json:modelPath` is rewritten in the
- * same call so the next embedder run finds the relocated ONNX bytes instead
- * of re-downloading multi-MB binaries (#735).
- *
- * Idempotent and safe to call from session start.
- */
-export function migrateClaudeFlowToMoflo(projectRoot) {
-    const legacy = legacyClaudeFlowDir(projectRoot);
-    const target = mofloDir(projectRoot);
-    if (!existsSync(legacy))
-        return { migrated: false, reason: 'no-legacy' };
-    if (!existsSync(target)) {
-        // Wholesale rename — count what's about to move so the launcher can
-        // report `migrated N files` instead of opaque "migrated runtime state".
-        let movedCount = 0;
-        try {
-            movedCount = readdirSync(legacy).length;
-        }
-        catch { /* count is cosmetic */ }
-        renameSync(legacy, target);
-        rewriteEmbeddingsModelPath(projectRoot);
-        return { migrated: true, movedCount };
-    }
-    let entries;
-    try {
-        entries = readdirSync(legacy);
-    }
-    catch {
-        return { migrated: false, reason: 'legacy-unreadable' };
-    }
-    let moved = 0;
-    let modelsMoved = false;
-    const collisions = [];
-    for (const name of entries) {
-        const dst = join(target, name);
-        if (existsSync(dst)) {
-            collisions.push(name); // target wins — but the launcher must warn
-            continue;
-        }
-        try {
-            renameSync(join(legacy, name), dst);
-            moved++;
-            if (name === 'models')
-                modelsMoved = true;
-        }
-        catch {
-            // Best-effort merge — a failed move on one entry shouldn't abort the rest.
-        }
-    }
-    // Drop empty legacy dir so future runs short-circuit at existsSync(legacy).
-    try {
-        if (readdirSync(legacy).length === 0)
-            rmdirSync(legacy);
-    }
-    catch {
-        // Non-fatal — leftover legacy dir just means migration runs next time.
-    }
-    if (modelsMoved)
-        rewriteEmbeddingsModelPath(projectRoot);
-    if (moved === 0) {
-        return { migrated: false, reason: 'merged-nothing', movedCount: 0, collisions };
-    }
-    return { migrated: true, movedCount: moved, collisions };
-}
-/**
- * Rewrite `.moflo/embeddings.json:modelPath` if it still references the
- * legacy `.claude-flow/` location. Called after a models/ relocation so the
- * stale path doesn't force a multi-MB re-download (#735).
- *
- * Best-effort: file-not-present, malformed JSON, missing `modelPath`, or
- * already-correct path are all silent no-ops. Returns true only when the
- * file was actually rewritten. Uses atomicWriteFileSync so a SIGINT mid-flush
- * can't truncate embeddings.json and break every subsequent embedder run.
- */
-export function rewriteEmbeddingsModelPath(projectRoot) {
-    const cfgPath = join(projectRoot, MOFLO_DIR, 'embeddings.json');
-    let raw;
-    try {
-        raw = readFileSync(cfgPath, 'utf8');
-    }
-    catch {
-        return false;
-    }
-    let cfg;
-    try {
-        cfg = JSON.parse(raw);
-    }
-    catch {
-        return false;
-    }
-    if (typeof cfg.modelPath !== 'string')
-        return false;
-    if (!cfg.modelPath.includes(LEGACY_CLAUDE_FLOW_DIR))
-        return false;
-    // split-join handles every occurrence and works with both `/` and `\\`
-    // (escaped) forms in JSON-encoded Windows paths.
-    cfg.modelPath = cfg.modelPath.split(LEGACY_CLAUDE_FLOW_DIR).join(MOFLO_DIR);
-    try {
-        atomicWriteFileSync(cfgPath, JSON.stringify(cfg, null, 2));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-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.1';
+export const VERSION = '4.9.3';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.9.1",
+  "version": "4.9.3",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -79,7 +79,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.9.0",
+    "moflo": "^4.9.2",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"