moflo 4.10.11 → 4.10.13

package/dist/src/cli/commands/doctor-checks-config.js

@@ -3,12 +3,12 @@
  * config files, statusLine, daemon, MCP servers, moflo.yaml compliance,
  * test directories.
  */
-import { existsSync, readFileSync, statSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, relative } from 'path';
 import os from 'os';
 import { findProjectDaemonPids, getDaemonLockHolder, getDaemonLockPayload, } from '../services/daemon-lock.js';
 import { resolveClientPort, LEGACY_DEFAULT_PORT, probeDaemonHealthWithRetry as probeDaemonHealthIdentity, normalizeProjectRoot, } from '../services/daemon-port.js';
-import { LEGACY_SWARM_DIR, memoryDbCandidatePaths, memoryDbPath, } from '../services/moflo-paths.js';
+import { COMMON_WALK_SKIP_NAMES, LEGACY_SWARM_DIR, memoryDbCandidatePaths, memoryDbPath, } from '../services/moflo-paths.js';
 import { probeDbIntegrity } from '../services/memory-db-integrity-repair.js';
 import { findProjectRoot } from '../services/project-root.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
@@ -272,6 +272,12 @@ export async function checkMemoryDatabase() {
  *  - `memory.db` / `memory.db.bak` — stale once `.moflo/moflo.db` exists.
  *  - `q-learning-model.json` / `model-router-state.json` — live router state
  *    that pre-dates the `.moflo/movector/` defaults; migrate, don't delete.
+ *  - `lora-weights.json` / `moe-weights.json` — LoRA + MoE weights (#1168
+ *    moved the writers to `.moflo/movector/`).
+ *  - `ewc-fisher.json` / `sona-patterns.json` — neural runtime state (#1168
+ *    moved the writers to `.moflo/neural/`).
+ *  - `state.json` — `flo swarm init` snapshot (#1168 → `.moflo/swarm/`).
+ *  - `code-map-hash.txt` — `flo memory code-map` cache (#1168 → `.moflo/memory/`).
  *  - `hooks.log` / `background.log` — diagnostic logs the launcher used to
  *    route to `.swarm/`; relocate to `.moflo/logs/`.
  *
@@ -291,6 +297,16 @@ export async function checkSwarmResidue() {
         'memory.db.bak',
         'q-learning-model.json',
         'model-router-state.json',
+        'lora-weights.json',
+        'moe-weights.json',
+        'ewc-fisher.json',
+        'sona-patterns.json',
+        'state.json',
+        'code-map-hash.txt',
+        // patterns-hash.txt + tests-hash.txt are pre-#699 residue (writers now
+        // target `.moflo/` directly). Surfaced + migrated by #1170.
+        'patterns-hash.txt',
+        'tests-hash.txt',
         'hooks.log',
         'background.log',
     ];
@@ -305,6 +321,128 @@ export async function checkSwarmResidue() {
         fix: 'flo healer --fix -c swarm-residue',
     };
 }
+/**
+ * Cap on `found.length` so a pathological monorepo (or adversarial layout)
+ * can't accumulate an unbounded array. 50 islands is already 50× more than
+ * any legitimate consumer should ever have; surfacing more would just bury
+ * the actionable signal in noise. Setting `truncated = true` signals the
+ * walker stopped early so the doctor message can hint at re-running with
+ * something more targeted.
+ */
+const NESTED_BFS_MAX_FOUND = 50;
+function scanNestedMofloDirs(root, maxDepth = 5) {
+    const found = [];
+    let truncated = false;
+    function walk(dir, depth) {
+        if (found.length >= NESTED_BFS_MAX_FOUND) {
+            truncated = true;
+            return;
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const lower = entry.name.toLowerCase();
+            if (COMMON_WALK_SKIP_NAMES.has(lower))
+                continue;
+            // Skip any .moflo* directory — both the canonical `.moflo` (we're
+            // looking for nested ones, not this level's own) and archived
+            // `.moflo-archived-*` produced by `flo doctor --fix`.
+            if (lower.startsWith('.moflo'))
+                continue;
+            if (entry.name.startsWith('.') && depth > 0)
+                continue;
+            const childDir = join(dir, entry.name);
+            if (existsSync(join(childDir, '.moflo', 'moflo.db'))) {
+                found.push(childDir);
+                if (found.length >= NESTED_BFS_MAX_FOUND) {
+                    truncated = true;
+                    return;
+                }
+                // Don't recurse below a nested island — its own descendants would
+                // be conflated under that residue.
+                continue;
+            }
+            if (depth + 1 > maxDepth) {
+                truncated = true;
+                continue;
+            }
+            walk(childDir, depth + 1);
+            if (found.length >= NESTED_BFS_MAX_FOUND)
+                return;
+        }
+    }
+    walk(root, 0);
+    return { islands: found, truncated };
+}
+function findNestedMofloDirs(root, maxDepth = 5) {
+    return scanNestedMofloDirs(root, maxDepth).islands;
+}
+/**
+ * Public wrapper for the BFS used by `checkNestedMofloIslands`. Exposed so
+ * `doctor-fixes.ts:fixNestedMofloIslands` can enumerate the same set without
+ * duplicating the skip-list / depth-bound logic. Returns parent directories
+ * (the consumer joins `.moflo` itself).
+ */
+export function findNestedMofloDirsForFix(root) {
+    return findNestedMofloDirs(root);
+}
+/**
+ * Surface nested `.moflo/moflo.db` directories — every one of them is a daemon
+ * island in a monorepo (#1174). The MCP server, daemon, and CLI tools each
+ * resolve their own anchor via cwd; pre-#1174 the resolver returned the
+ * *nearest* ancestor, so subdirectory invocations silently spawned isolated
+ * daemons with separate sockets, ports, registries, and vector state.
+ *
+ * Status semantics:
+ *  - `pass` — no nested `.moflo/` directories under the canonical project root.
+ *  - `warn` — one or more nested `.moflo/` directories detected; lists each
+ *    with its relative path. `fix` points at the auto-fix that archives them.
+ *
+ * Auto-fix (`fixNestedMofloIslands` in doctor-fixes.ts) renames each nested
+ * `.moflo/` to `.moflo-archived-<ISO>/` so the user can manually inspect or
+ * restore them. Daemons running out of those nested directories are stopped
+ * first.
+ */
+export async function checkNestedMofloIslands(cwd) {
+    const root = cwd ?? findProjectRoot();
+    let scan;
+    try {
+        scan = scanNestedMofloDirs(root);
+    }
+    catch (e) {
+        return {
+            name: 'Nested .moflo/ Islands',
+            status: 'warn',
+            message: `Walk failed: ${errorDetail(e, { firstLineOnly: true })}`,
+        };
+    }
+    const { islands, truncated } = scan;
+    if (islands.length === 0) {
+        const baseMsg = 'No nested .moflo/ directories detected';
+        return {
+            name: 'Nested .moflo/ Islands',
+            status: truncated ? 'warn' : 'pass',
+            message: truncated
+                ? `${baseMsg} within depth-5 walk — deeper subtrees not inspected`
+                : baseMsg,
+        };
+    }
+    const rels = islands.map(p => relative(root, p) || '.');
+    const truncNote = truncated ? ' (walk truncated at depth 5 — deeper islands may exist)' : '';
+    return {
+        name: 'Nested .moflo/ Islands',
+        status: 'warn',
+        message: `${islands.length} nested .moflo/ ${islands.length === 1 ? 'directory' : 'directories'} (#1174): ${rels.join(', ')}${truncNote}`,
+        fix: 'flo healer --fix -c nested-moflo',
+    };
+}
 /**
  * Tier-1 corruption probe for `.moflo/moflo.db`. Runs `PRAGMA integrity_check`
  * via a raw node:sqlite readonly handle — bypasses `openBackend` because that

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

@@ -11,7 +11,7 @@ import { output } from '../output.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { atomicWriteFileSync } from '../shared/utils/atomic-file-write.js';
 import { repairHookWiring } from '../services/hook-wiring.js';
-import { getDaemonLockHolder } from '../services/daemon-lock.js';
+import { findProjectDaemonPids, 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';
@@ -152,10 +152,32 @@ async function fixSwarmLegacyResidue() {
             allMigrated = false;
         }
     }
-    // (2) router state JSONs — rename into .moflo/movector/.
+    // (2) router state + neural state JSONs — rename into .moflo/{movector,neural,swarm,memory}/.
+    //
+    // q-learning-model.json + model-router-state.json: shipped at #727.
+    // lora-weights.json + moe-weights.json: writer relocation in #1168
+    //   (lora-adapter.ts, moe-router.ts).
+    // ewc-fisher.json + sona-patterns.json: writer relocation in #1168
+    //   (ewc-consolidation.ts, sona-optimizer.ts).
+    // state.json + code-map-hash.txt: writer relocation in #1168
+    //   (commands/swarm.ts, commands/memory.ts).
+    const neuralDir = join(moflo, 'neural');
+    const swarmStateDir = join(moflo, 'swarm');
+    const memoryStateDir = join(moflo, 'memory');
+    // patterns-hash.txt + tests-hash.txt: writers in bin/index-patterns.mjs +
+    //   bin/index-tests.mjs already target `.moflo/` directly (post-#699). Any
+    //   `.swarm/` copies are pre-#699 residue with no active writer (#1170).
     const stateFiles = [
         { name: 'q-learning-model.json', dest: movectorDir },
         { name: 'model-router-state.json', dest: movectorDir },
+        { name: 'lora-weights.json', dest: movectorDir },
+        { name: 'moe-weights.json', dest: movectorDir },
+        { name: 'ewc-fisher.json', dest: neuralDir },
+        { name: 'sona-patterns.json', dest: neuralDir },
+        { name: 'state.json', dest: swarmStateDir },
+        { name: 'code-map-hash.txt', dest: memoryStateDir },
+        { name: 'patterns-hash.txt', dest: moflo },
+        { name: 'tests-hash.txt', dest: moflo },
     ];
     for (const { name, dest } of stateFiles) {
         const src = join(swarmDir, name);
@@ -220,6 +242,169 @@ async function fixSwarmLegacyResidue() {
     }
     return allMigrated;
 }
+/**
+ * Stop any moflo daemons owned by `subRoot` before archiving its `.moflo/`.
+ *
+ * Pre-#1174 nested-daemon PIDs are not visible to the canonical orphan reap
+ * (which uses the topmost projectRoot's CLI candidate paths). Calling
+ * `findProjectDaemonPids` with the SUB-root finds them. SIGTERM first, wait a
+ * brief grace, SIGKILL if still alive. On Windows, daemons holding files in
+ * `.moflo/` would otherwise cause `renameSync` to fail with EBUSY; on POSIX,
+ * the rename succeeds but the daemon's open FDs keep pointing at the inode.
+ */
+/**
+ * `process.kill` failure modes worth distinguishing:
+ *   - `ESRCH` — no such process (already exited). Treat as success.
+ *   - `EPERM` — caller lacks permission (POSIX: daemon owned by another user;
+ *     Windows: insufficient ACLs). The signal was NOT delivered. We must
+ *     report this as "remaining" so the caller doesn't archive `.moflo/`
+ *     thinking the daemon is gone.
+ *   - other — surface as remaining + log; don't crash the fix path.
+ */
+function killOutcome(err) {
+    const code = err?.code;
+    if (code === 'ESRCH')
+        return 'gone';
+    if (code === 'EPERM')
+        return 'denied';
+    return 'unknown';
+}
+async function stopNestedDaemons(subRoot) {
+    let pids = [];
+    try {
+        pids = findProjectDaemonPids(subRoot);
+    }
+    catch {
+        return { stopped: [], remaining: [], denied: [] };
+    }
+    if (pids.length === 0)
+        return { stopped: [], remaining: [], denied: [] };
+    const stopped = [];
+    const denied = [];
+    for (const pid of pids) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            stopped.push(pid);
+        }
+        catch (err) {
+            const outcome = killOutcome(err);
+            if (outcome === 'gone')
+                continue; // already exited
+            if (outcome === 'denied')
+                denied.push(pid); // wrong-owner daemon
+            else
+                denied.push(pid); // unknown — treat as undelivered
+        }
+    }
+    // Poll for exit with a 1s deadline (matches the daemon-service stop loop in
+    // commands/daemon.ts). Async-by-default — busy-waiting here would pin CPU
+    // during the very contention we're waiting out (see feedback memory).
+    const deadline = Date.now() + 1000;
+    while (Date.now() < deadline) {
+        const alive = stopped.filter(pid => {
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (alive.length === 0)
+            break;
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    const remaining = [];
+    for (const pid of stopped) {
+        let stillAlive = false;
+        try {
+            process.kill(pid, 0);
+            stillAlive = true;
+        }
+        catch { /* gone */ }
+        if (!stillAlive)
+            continue;
+        // Still alive — escalate.
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch (err) {
+            if (killOutcome(err) === 'denied') {
+                denied.push(pid);
+                continue;
+            }
+            // Other errors (incl. ESRCH on race) — re-probe below.
+        }
+        try {
+            process.kill(pid, 0);
+            remaining.push(pid);
+        }
+        catch { /* gone */ }
+    }
+    return { stopped, remaining, denied };
+}
+/**
+ * Archive nested `.moflo/` directories that fragment monorepo state (#1174).
+ *
+ * Each nested `.moflo/` is renamed to `.moflo-archived-<ISO>` in place. Never
+ * deletes — sub-daemon vector state can be uniquely useful (subworkspace-
+ * specific learnings) and silently dropping it would be the wrong default.
+ * The user can manually inspect or restore archived directories.
+ *
+ * Daemon reap: before each rename, `findProjectDaemonPids(island)` enumerates
+ * any moflo daemons whose cmdline references the sub-root, then SIGTERMs them
+ * (escalates to SIGKILL after 1s). This is required for both platforms:
+ *   - Windows: `renameSync` fails with EBUSY if any file is open. Without the
+ *     reap, archive silently fails until the user manually stops the daemon.
+ *   - POSIX: rename succeeds but the daemon's open FDs keep pointing at the
+ *     inode; the daemon keeps writing to a now-archived path until it exits.
+ */
+async function fixNestedMofloIslands() {
+    const root = findProjectRoot();
+    let islands;
+    try {
+        const { findNestedMofloDirsForFix } = await import('./doctor-checks-config.js');
+        islands = findNestedMofloDirsForFix(root);
+    }
+    catch (e) {
+        output.writeln(output.warning(`  Unable to enumerate nested .moflo/: ${errorDetail(e)}`));
+        return false;
+    }
+    if (islands.length === 0)
+        return true;
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    let allArchived = true;
+    for (const island of islands) {
+        const src = join(island, '.moflo');
+        const dst = join(island, `.moflo-archived-${ts}`);
+        if (!existsSync(src))
+            continue;
+        // Step 1: stop any sub-daemon. The canonical projectRoot-based orphan
+        // scan can't see nested daemons; we have to enumerate from the sub-root.
+        const { stopped, remaining, denied } = await stopNestedDaemons(island);
+        if (stopped.length > 0) {
+            output.writeln(output.dim(`  ${island}: stopped daemon PID${stopped.length === 1 ? '' : 's'} ${stopped.join(', ')}.`));
+        }
+        if (denied.length > 0) {
+            output.writeln(output.warning(`  ${island}: permission denied stopping PID${denied.length === 1 ? '' : 's'} ${denied.join(', ')} — daemon owned by another user; stop it manually before re-running this fix.`));
+            allArchived = false;
+        }
+        if (remaining.length > 0) {
+            output.writeln(output.warning(`  ${island}: PID${remaining.length === 1 ? '' : 's'} ${remaining.join(', ')} survived SIGKILL — manual intervention required.`));
+            allArchived = false;
+        }
+        try {
+            renameSync(src, dst);
+            output.writeln(output.success(`  Archived: ${island}/.moflo → .moflo-archived-${ts}/`));
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Failed to archive ${island}/.moflo: ${errorDetail(e)}. ` +
+                `If a process still holds files open, stop it manually and re-run \`flo doctor --fix -c nested-moflo\`.`));
+            allArchived = false;
+        }
+    }
+    return allArchived;
+}
 /**
  * Execute the fix for a failed/warned health check.
  * Returns true if the fix succeeded (re-check should pass).
@@ -230,10 +415,11 @@ export async function autoFixCheck(check) {
     // Map checks to programmatic fixes (not just shell commands)
     const fixActions = {
         'Memory Database': async () => {
+            // Canonical DB lives at `.moflo/moflo.db`; `initializeMemoryDatabase`
+            // creates the parent dir itself. The pre-#1168 fix also `mkdirSync`'d
+            // `.swarm/` — vestigial residue that fought the 'Swarm Residue' fix in
+            // the same healer pass. Removed.
             try {
-                const swarmDir = join(process.cwd(), '.swarm');
-                if (!existsSync(swarmDir))
-                    mkdirSync(swarmDir, { recursive: true });
                 const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
                 const result = await initializeMemoryDatabase({ force: true, verbose: false });
                 return result.success;
@@ -243,12 +429,11 @@ export async function autoFixCheck(check) {
             }
         },
         'Embeddings': async () => {
+            // Same fix as Memory Database — ensure the canonical DB exists, then
+            // populate embeddings. Pre-#1168 wrote to `.swarm/memory.db` directly,
+            // contradicting the post-#727 layout; that branch is removed.
             try {
-                const swarmDir = join(process.cwd(), '.swarm');
-                if (!existsSync(swarmDir))
-                    mkdirSync(swarmDir, { recursive: true });
-                const dbPath = join(swarmDir, 'memory.db');
-                if (!existsSync(dbPath)) {
+                if (!existsSync(memoryDbPath(findProjectRoot()))) {
                     const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
                     await initializeMemoryDatabase({ force: true, verbose: false });
                 }
@@ -572,6 +757,13 @@ export async function autoFixCheck(check) {
         'Swarm Residue': async () => {
             return fixSwarmLegacyResidue();
         },
+        // Archive nested `.moflo/` directories that fragment monorepo state
+        // (#1174). Rename, never delete — sub-daemon vector state can be unique
+        // and silently losing it would be the wrong default. The archive name
+        // includes an ISO timestamp so re-runs don't collide.
+        'Nested .moflo/ Islands': async () => {
+            return fixNestedMofloIslands();
+        },
         '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, checkDaemonIdentity, checkDaemonOrphan, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMemoryDbIntegrity, checkMofloYamlCompliance, checkStatusLine, checkSwarmResidue, checkTestDirs, } from './doctor-checks-config.js';
+import { checkConfigFile, checkDaemonIdentity, checkDaemonOrphan, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMemoryDbIntegrity, checkMofloYamlCompliance, checkNestedMofloIslands, 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';
@@ -42,6 +42,10 @@ export const allChecks = [
     checkDaemonWriteRouting,
     checkWritersAudit,
     checkMemoryDatabase,
+    // Surfaces nested `.moflo/moflo.db` directories — every nested instance is
+    // a daemon island in a monorepo (#1174). Runs cheap (depth-bounded BFS,
+    // statSync only) and independent of memory-DB integrity probes.
+    checkNestedMofloIslands,
     // 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).
@@ -111,6 +115,10 @@ export const componentMap = {
     'writers-audit': checkWritersAudit,
     'writers': checkWritersAudit,
     'memory': checkMemoryDatabase,
+    'nested-moflo': checkNestedMofloIslands,
+    'nested': checkNestedMofloIslands,
+    'islands': checkNestedMofloIslands,
+    'monorepo': checkNestedMofloIslands,
     'swarm-residue': checkSwarmResidue,
     'residue': checkSwarmResidue,
     'memory-db-integrity': checkMemoryDbIntegrity,

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

@@ -7,6 +7,7 @@ import { confirm, select, multiSelect, input } from '../prompt.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { findAncestorMofloRoot } from '../services/project-root.js';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
 // Check if project is already initialized
 function isInitialized(cwd) {
@@ -25,6 +26,38 @@ const initAction = async (ctx) => {
     const skipClaude = ctx.flags.skipClaude;
     const onlyClaude = ctx.flags.onlyClaude;
     const cwd = ctx.cwd;
+    // ── Monorepo nested-.moflo guard (#1174) ───────────────────────────
+    // Initializing inside a sub-directory whose ancestor already has
+    // .moflo/moflo.db creates a daemon island: the MCP server, daemon, and CLI
+    // tools end up bound to different daemons depending on cwd. Default to
+    // using the ancestor's state; --force lets the user opt in to a nested
+    // setup (rare, almost always a misconfiguration).
+    const ancestorMoflo = findAncestorMofloRoot(cwd);
+    if (ancestorMoflo && !force) {
+        output.printWarning('Monorepo detected: ancestor moflo project found.');
+        output.printInfo(`  Ancestor: ${ancestorMoflo}`);
+        output.printInfo(`  This directory: ${cwd}`);
+        output.writeln();
+        output.writeln('Initializing here would create a nested .moflo/ — the MCP server and CLI tools');
+        output.writeln('would silently route to different daemons depending on cwd (issue #1174). Use the');
+        output.writeln('ancestor\'s state by running moflo commands from the ancestor instead.');
+        output.writeln();
+        if (ctx.interactive && !ctx.flags.yes) {
+            const proceed = await confirm({
+                message: 'Initialize anyway (creates a nested .moflo/)?',
+                default: false,
+            });
+            if (!proceed) {
+                output.printInfo('Aborted — use the ancestor moflo project.');
+                return { success: true, message: 'aborted by user (ancestor moflo project)' };
+            }
+        }
+        else {
+            output.printError('Refusing to create a nested .moflo/. Pass --force to override, or re-run from the ancestor.');
+            return { success: false, message: 'refused: nested .moflo/ in monorepo', exitCode: 1 };
+        }
+    }
+    // ── End monorepo guard ─────────────────────────────────────────────
     // ── MoFlo Project Setup ────────────────────────────────────────────
     // Always run MoFlo init to ensure moflo.yaml, hooks, skill, and
     // CLAUDE.md are set up, regardless of other init options.

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

@@ -9,6 +9,7 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { legacySwarmPath, runtimePath } from '../services/moflo-paths.js';
 // Memory backends
 const BACKENDS = [
     { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
@@ -2129,7 +2130,10 @@ const codeMapCommand = {
         const { execSync } = await import('child_process');
         const { createHash } = await import('crypto');
         const cwd = ctx.cwd || process.cwd();
-        const hashCachePath = pathModule.join(cwd, '.swarm', 'code-map-hash.txt');
+        // Post-#1168: canonical at `.moflo/memory/code-map-hash.txt`. Legacy
+        // `.swarm/code-map-hash.txt` is read-only fallback for upgrade scenarios.
+        const hashCachePath = runtimePath('memory', 'code-map-hash.txt');
+        const legacyHashCachePath = legacySwarmPath('code-map-hash.txt');
         output.writeln();
         output.writeln(output.bold('Generating Code Map'));
         output.writeln(output.dim('─'.repeat(50)));
@@ -2168,9 +2172,12 @@ const codeMapCommand = {
             output.writeln(`File list hash: ${currentHash.slice(0, 12)}...`);
             return { success: true };
         }
-        // Check if unchanged
-        if (!forceRegen && fs.existsSync(hashCachePath)) {
-            const cached = fs.readFileSync(hashCachePath, 'utf-8').trim();
+        // Check if unchanged — canonical first, then legacy `.swarm/` fallback.
+        const cachedReadPath = fs.existsSync(hashCachePath)
+            ? hashCachePath
+            : (fs.existsSync(legacyHashCachePath) ? legacyHashCachePath : null);
+        if (!forceRegen && cachedReadPath) {
+            const cached = fs.readFileSync(cachedReadPath, 'utf-8').trim();
             if (cached === currentHash) {
                 const { db } = await openDb(cwd);
                 const stmt = db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = ?`);

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

@@ -7,14 +7,26 @@ 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';
+import { LEGACY_SWARM_DIR, memoryDbCandidatePaths, mofloDir } from '../services/moflo-paths.js';
+import { findProjectRoot } from '../services/project-root.js';
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const projectRoot = findProjectRoot();
+    // `.moflo/swarm/state.json` is canonical post-#1168; `.swarm/state.json`
+    // is a read-only fallback so a consumer who initialised on an older moflo
+    // still sees their swarm. The pre-#1168 agents/tasks JSON probe blocks
+    // were removed — no current writer creates those directories, so they
+    // always produced 0 counts. The coordinator-backed MCP tools
+    // (agent_list / task_list) are the live source of truth.
+    const canonicalSwarmDir = path.join(mofloDir(projectRoot), 'swarm');
+    const legacySwarmDir = path.join(projectRoot, LEGACY_SWARM_DIR);
     const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
     const memoryPaths = memoryDbCandidatePaths(process.cwd());
-    // Check for active swarm state file
-    const swarmStateFile = path.join(swarmDir, 'state.json');
+    // Check for active swarm state file — canonical first, then legacy.
+    let swarmStateFile = path.join(canonicalSwarmDir, 'state.json');
+    if (!fs.existsSync(swarmStateFile)) {
+        swarmStateFile = path.join(legacySwarmDir, 'state.json');
+    }
     let swarmState = null;
     if (fs.existsSync(swarmStateFile)) {
         try {
@@ -24,30 +36,14 @@ function getSwarmStatus(swarmId) {
             // Ignore parse errors
         }
     }
-    // Count active agents from process files
-    let activeAgents = 0;
-    let totalAgents = 0;
-    const agentsDir = path.join(swarmDir, 'agents');
-    if (fs.existsSync(agentsDir)) {
-        try {
-            const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.json'));
-            totalAgents = agentFiles.length;
-            for (const file of agentFiles) {
-                try {
-                    const agent = JSON.parse(fs.readFileSync(path.join(agentsDir, file), 'utf-8'));
-                    if (agent.status === 'active' || agent.status === 'running') {
-                        activeAgents++;
-                    }
-                }
-                catch {
-                    // Ignore
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
+    // agents/tasks counters: no file-store readers post-#1168. Coordinator
+    // MCP tools own the live counts; getSwarmStatus surfaces a static summary
+    // of the persisted state file plus session/memory rough indicators.
+    const activeAgents = 0;
+    const totalAgents = 0;
+    const completedTasks = 0;
+    const inProgressTasks = 0;
+    const pendingTasks = 0;
     // Get session count
     let sessionCount = 0;
     if (fs.existsSync(sessionDir)) {
@@ -71,36 +67,6 @@ function getSwarmStatus(swarmId) {
             }
         }
     }
-    // Count task files if they exist
-    let completedTasks = 0;
-    let inProgressTasks = 0;
-    let pendingTasks = 0;
-    const tasksDir = path.join(swarmDir, 'tasks');
-    if (fs.existsSync(tasksDir)) {
-        try {
-            const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
-            for (const file of taskFiles) {
-                try {
-                    const task = JSON.parse(fs.readFileSync(path.join(tasksDir, file), 'utf-8'));
-                    if (task.status === 'completed' || task.status === 'done') {
-                        completedTasks++;
-                    }
-                    else if (task.status === 'in_progress' || task.status === 'running') {
-                        inProgressTasks++;
-                    }
-                    else {
-                        pendingTasks++;
-                    }
-                }
-                catch {
-                    // Ignore
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
     // Calculate dynamic progress based on actual state
     // If no swarm state, show 0%. Otherwise calculate from completed tasks
     const totalTasks = completedTasks + inProgressTasks + pendingTasks;
@@ -279,8 +245,11 @@ const initCommand = {
             });
             output.writeln();
             output.printSuccess('Swarm initialized successfully');
-            // Save swarm state locally for status command to read
-            const swarmDir = path.join(process.cwd(), '.swarm');
+            // Save swarm state locally for status command to read. Post-#1168 the
+            // canonical home is `<root>/.moflo/swarm/state.json`; the legacy
+            // `.swarm/state.json` path is preserved as a read-only fallback in
+            // `getSwarmStatus`.
+            const swarmDir = path.join(mofloDir(findProjectRoot()), 'swarm');
             try {
                 if (!fs.existsSync(swarmDir)) {
                     fs.mkdirSync(swarmDir, { recursive: true });