moflo 4.12.2 → 4.12.3-rc.1

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

@@ -12,7 +12,7 @@ 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 { findProjectDaemonPids, getDaemonLockHolder } from '../services/daemon-lock.js';
-import { findProjectRoot } from '../services/project-root.js';
+import { findProjectRoot, resolveStateRoot } from '../services/project-root.js';
 import { legacyMemoryDbPath, legacyMemoryDbBakPath, memoryDbPath, mofloDir } from '../services/moflo-paths.js';
 import { findZombieProcesses } from './doctor-zombies.js';
 import { inspectMcpConfigs } from './doctor-checks-config.js';
@@ -274,9 +274,20 @@ async function stopNestedDaemons(subRoot) {
     try {
         pids = findProjectDaemonPids(subRoot);
     }
-    catch {
-        return { stopped: [], remaining: [], denied: [] };
+    catch { /* cmdline scan unavailable — the lock-file probe below still runs */ }
+    // #1315 — the cmdline scan alone cannot see a HUSK daemon. `projectCliCandidates`
+    // matches processes whose command line invokes `<subRoot>/node_modules/moflo/bin/cli.js`,
+    // but a husk daemon resolved its binary from the ROOT install and only its
+    // CWD was the sub-directory — so nothing matches, nothing is reaped, and the
+    // archive that follows either fails EBUSY on Windows (open daemon.log fd) or
+    // succeeds on POSIX only for the daemon's next tick to recreate the dir.
+    // The lock file is the dependable handle: a husk always contains one.
+    try {
+        const holder = getDaemonLockHolder(subRoot);
+        if (holder !== null && !pids.includes(holder))
+            pids.push(holder);
     }
+    catch { /* no lock or unreadable — nothing more we can do */ }
     if (pids.length === 0)
         return { stopped: [], remaining: [], denied: [] };
     const stopped = [];
@@ -360,7 +371,11 @@ async function stopNestedDaemons(subRoot) {
  *     inode; the daemon keeps writing to a now-archived path until it exits.
  */
 async function fixNestedMofloIslands() {
-    const root = findProjectRoot();
+    // #1315 — `resolveStateRoot`, not `findProjectRoot`. The latter returns
+    // `CLAUDE_PROJECT_DIR` unconditionally, so running the healer from a
+    // sub-workspace session would scan for islands starting AT a sub-workspace —
+    // missing the real ones above it, and treating that directory as canonical.
+    const root = resolveStateRoot();
     let islands;
     try {
         const { findNestedMofloDirsForFix } = await import('./doctor-checks-config.js');
@@ -445,7 +460,7 @@ export async function autoFixCheck(check) {
         },
         'Config File': async () => {
             try {
-                const cfDir = join(process.cwd(), '.moflo');
+                const cfDir = join(resolveStateRoot(), '.moflo');
                 if (!existsSync(cfDir))
                     mkdirSync(cfDir, { recursive: true });
                 return runFixCommand('npx moflo config init');

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

@@ -11,6 +11,7 @@ import { execSync } from 'child_process';
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { getDaemonLockHolder, isDaemonProcess, releaseDaemonLock } from '../services/daemon-lock.js';
+import { resolveStateRoot } from '../services/project-root.js';
 // Cmdline capture/display caps + scan timeouts. Hoisted so the values
 // used to size buffers and format messages are visible in one place.
 const ZOMBIE_CMDLINE_CAPTURE_LEN = 200;
@@ -41,8 +42,8 @@ function isProcessAlive(pid) {
 // Fast path: kill processes tracked in the shared ProcessManager registry.
 // This avoids the expensive OS-level process scan for known background tasks.
 export function killTrackedProcesses() {
-    const registryFile = join(process.cwd(), '.moflo', 'background-pids.json');
-    const lockFile = join(process.cwd(), '.moflo', 'spawn.lock');
+    const registryFile = join(resolveStateRoot(), '.moflo', 'background-pids.json');
+    const lockFile = join(resolveStateRoot(), '.moflo', 'spawn.lock');
     let killed = 0;
     try {
         if (existsSync(registryFile)) {
@@ -80,7 +81,7 @@ export function killTrackedProcesses() {
 // findZombieProcesses() flags every running indexer step as a zombie.
 function readTrackedBackgroundPids() {
     const result = new Set();
-    const registryFile = join(process.cwd(), '.moflo', 'background-pids.json');
+    const registryFile = join(resolveStateRoot(), '.moflo', 'background-pids.json');
     try {
         if (!existsSync(registryFile))
             return result;

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

@@ -18,6 +18,7 @@ import { memoryDbPath, MEMORY_DB_FILE, MOFLO_DIR } from '../services/moflo-paths
 import * as embeddings from '../embeddings/index.js';
 import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { resolveStateRoot } from '../services/project-root.js';
 const DEFAULT_DB_PATH_FLAG = `${MOFLO_DIR}/${MEMORY_DB_FILE}`;
 // Generate subcommand - REAL implementation
 const generateCommand = {
@@ -110,7 +111,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.dbPath || memoryDbPath(process.cwd());
+        const dbPath = ctx.flags.dbPath || memoryDbPath(resolveStateRoot());
         if (!query) {
             output.printError('Query is required');
             return { success: false, exitCode: 1 };
@@ -355,7 +356,7 @@ const collectionsCommand = {
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
-        const dbPath = ctx.flags.dbPath || memoryDbPath(process.cwd());
+        const dbPath = ctx.flags.dbPath || memoryDbPath(resolveStateRoot());
         output.writeln();
         output.writeln(output.bold('Embedding Collections (Namespaces)'));
         output.writeln(output.dim('─'.repeat(60)));
@@ -605,7 +606,10 @@ export const initCommand = {
         try {
             const fs = await import('fs');
             const path = await import('path');
-            const configDir = path.join(process.cwd(), '.moflo');
+            // #1315 — resolved root, not cwd. This mkdirs below, so `flo embeddings
+            // init` from a subdirectory minted an island holding an embeddings config
+            // the rest of the stack would never look at.
+            const configDir = path.join(resolveStateRoot(), '.moflo');
             const configPath = path.join(configDir, 'embeddings.json');
             // Second-session path: config already exists. Skip download / rewrite,
             // but still run the migration check so users upgrading moflo mid-project
@@ -942,7 +946,8 @@ const neuralCommand = {
         // Check if embeddings config exists
         const fs = await import('fs');
         const path = await import('path');
-        const configPath = path.join(process.cwd(), '.moflo', 'embeddings.json');
+        // #1315 — must read from the root `init` writes to.
+        const configPath = path.join(resolveStateRoot(), '.moflo', 'embeddings.json');
         if (!fs.existsSync(configPath)) {
             output.printWarning('Embeddings not initialized');
             output.printInfo('Run "embeddings init" first to configure ONNX model');
@@ -1475,7 +1480,7 @@ const migrateCommand = {
         { command: 'flo embeddings migrate -d .custom/mem.db', description: 'Migrate a custom DB' },
     ],
     action: async (ctx) => {
-        const dbPath = ctx.flags.db || memoryDbPath(process.cwd());
+        const dbPath = ctx.flags.db || memoryDbPath(resolveStateRoot());
         try {
             const ran = await runEmbeddingsMigrationIfNeeded({ dbPath });
             return { success: true, data: { ran } };

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

@@ -8,6 +8,9 @@ import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+// #1315 — the intelligence/maturity probes below read `.moflo/` state; anchor
+// them at the resolved root so a subdirectory invocation doesn't report zeroes.
+import { resolveStateRoot } from '../services/project-root.js';
 // Hook types
 const HOOK_TYPES = [
     { value: 'pre-edit', label: 'Pre-Edit', hint: 'Get context before editing files' },
@@ -2501,7 +2504,7 @@ const statuslineCommand = {
         const { execSync } = await import('child_process');
         // Get learning stats from memory database
         function getLearningStats() {
-            const memoryPaths = memoryDbCandidatePaths(process.cwd());
+            const memoryPaths = memoryDbCandidatePaths(resolveStateRoot());
             let patterns = 0;
             let sessions = 0;
             let trajectories = 0;
@@ -2611,7 +2614,7 @@ const statuslineCommand = {
             let intelligencePct = 0;
             // 1. Check learning.json for REAL intelligence metrics first
             const learningJsonPaths = [
-                path.join(process.cwd(), '.moflo', 'learning.json'),
+                path.join(resolveStateRoot(), '.moflo', 'learning.json'),
                 path.join(process.cwd(), '.claude', '.moflo', 'learning.json'),
                 path.join(process.cwd(), '.swarm', 'learning.json'),
             ];
@@ -2639,7 +2642,7 @@ const statuslineCommand = {
                 // Check for key project files/dirs
                 if (fs.existsSync(path.join(process.cwd(), '.claude')))
                     maturityScore += 15;
-                if (fs.existsSync(path.join(process.cwd(), '.moflo')))
+                if (fs.existsSync(path.join(resolveStateRoot(), '.moflo')))
                     maturityScore += 15;
                 if (fs.existsSync(path.join(process.cwd(), 'CLAUDE.md')))
                     maturityScore += 10;
@@ -2754,10 +2757,10 @@ const statuslineCommand = {
         const agentdbStats = { vectorCount: 0, dbSizeKB: 0, hasHnsw: false };
         // Check for direct database files first. Canonical first, legacies after.
         const dbPaths = [
-            ...memoryDbCandidatePaths(process.cwd()),
+            ...memoryDbCandidatePaths(resolveStateRoot()),
             path.join(process.cwd(), 'memory.db'),
             path.join(process.cwd(), '.agentdb', 'memory.db'),
-            path.join(process.cwd(), '.moflo', 'memory', 'agentdb.db'),
+            path.join(resolveStateRoot(), '.moflo', 'memory', 'agentdb.db'),
         ];
         for (const dbPath of dbPaths) {
             if (fs.existsSync(dbPath)) {
@@ -2774,7 +2777,7 @@ const statuslineCommand = {
         // Check for AgentDB directories if no direct db found
         if (agentdbStats.vectorCount === 0) {
             const agentdbDirs = [
-                path.join(process.cwd(), '.moflo', 'agentdb'),
+                path.join(resolveStateRoot(), '.moflo', 'agentdb'),
                 path.join(process.cwd(), '.swarm', 'agentdb'),
                 path.join(process.cwd(), 'data', 'agentdb'),
                 path.join(process.cwd(), '.agentdb'),
@@ -2801,7 +2804,7 @@ const statuslineCommand = {
         }
         // Check for HNSW index files
         const hnswPaths = [
-            path.join(process.cwd(), '.moflo', 'hnsw'),
+            path.join(resolveStateRoot(), '.moflo', 'hnsw'),
             path.join(process.cwd(), '.swarm', 'hnsw'),
             path.join(process.cwd(), 'data', 'hnsw'),
         ];
@@ -2822,7 +2825,7 @@ const statuslineCommand = {
             }
         }
         // Check for vectors.json file
-        const vectorsPath = path.join(process.cwd(), '.moflo', 'vectors.json');
+        const vectorsPath = path.join(resolveStateRoot(), '.moflo', 'vectors.json');
         if (fs.existsSync(vectorsPath) && agentdbStats.vectorCount === 0) {
             try {
                 const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));

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

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { LEGACY_SWARM_DIR, memoryDbCandidatePaths, mofloDir } from '../services/moflo-paths.js';
 import { findProjectRoot } from '../services/project-root.js';
+import { resolveStateRoot } from '../services/project-root.js';
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
     const projectRoot = findProjectRoot();
@@ -21,7 +22,7 @@ function getSwarmStatus(swarmId) {
     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());
+    const memoryPaths = memoryDbCandidatePaths(resolveStateRoot());
     // Check for active swarm state file — canonical first, then legacy.
     let swarmStateFile = path.join(canonicalSwarmDir, 'state.json');
     if (!fs.existsSync(swarmStateFile)) {

package/dist/src/cli/index.js

@@ -12,6 +12,7 @@ import { runStartupUpdateCheck } from './update/index.js';
 import { loadMofloConfig } from './config/moflo-config.js';
 import { getDaemonLockHolder } from './services/daemon-lock.js';
 import { registerBackgroundPid } from './services/process-registry.js';
+import { resolveStateRoot } from './services/project-root.js';
 import { VERSION } from './version.js';
 export { VERSION };
 const LONG_RUNNING_COMMANDS = ['mcp', 'daemon'];
@@ -479,25 +480,36 @@ export class CLI {
         // wants autostart can delete it in its own beforeEach, same as the others.
         if (process.env.MOFLO_TEST_SKIP_DAEMON_AUTOSTART === '1')
             return;
-        const config = loadMofloConfig(process.cwd());
+        // #1315 — anchor on the resolved project root, NOT cwd. Pre-fix, a `flo`
+        // invocation from a sub-workspace read the config from there, looked for a
+        // lock there (never finding the root daemon's, so the "already running?"
+        // check below always passed), and then spawned a second daemon bound to a
+        // freshly-minted `.moflo/` island.
+        const projectRoot = resolveStateRoot();
+        const config = loadMofloConfig(projectRoot);
         if (!config.daemon.auto_start)
             return;
-        // Already running?
-        const holder = getDaemonLockHolder(process.cwd());
+        // Already running? Checked at the resolved root so a subdirectory
+        // invocation sees the root daemon instead of spawning a rival.
+        const holder = getDaemonLockHolder(projectRoot);
         if (holder)
             return;
         // Dynamically import to avoid circular deps and keep CLI startup fast
         const { spawn } = await import('child_process');
         const { join } = await import('path');
-        const { existsSync, openSync, mkdirSync } = await import('fs');
+        const { existsSync, openSync } = await import('fs');
         const { locateMofloCliBin } = await import('./services/moflo-require.js');
         const cliPath = locateMofloCliBin();
         if (!cliPath)
             return;
-        const projectRoot = process.cwd();
         const stateDir = join(projectRoot, '.moflo');
+        // #1315 — an implicit auto-start must never MINT state. If there's no
+        // `.moflo/` at the resolved root this isn't an initialized moflo project,
+        // and creating one here is what produced stray islands seven levels deep
+        // inside consumer source trees. `flo init` and the explicit `daemon start`
+        // path still create it; auto-start only ever attaches to what exists.
         if (!existsSync(stateDir))
-            mkdirSync(stateDir, { recursive: true });
+            return;
         const logFile = join(stateDir, 'daemon.log');
         const isWin = process.platform === 'win32';
         const spawnArgs = [cliPath, 'daemon', 'start', '--foreground', '--quiet'];

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

@@ -9,7 +9,7 @@ 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';
-import { findProjectRoot } from '../services/project-root.js';
+import { resolveStateRoot } from '../services/project-root.js';
 // When run via npx, CWD may be node_modules/moflo — walk up to find actual project
 let _projectRoot;
 /**
@@ -66,7 +66,13 @@ export function searchCandidateCap() {
 function getProjectRoot() {
     if (_projectRoot)
         return _projectRoot;
-    _projectRoot = findProjectRoot();
+    // #1315 — MUST be the same resolver `entries-read`/`entries-write` use, or
+    // the bridge and the entry writers open DIFFERENT `.moflo/moflo.db` files.
+    // `findProjectRoot()` returns `CLAUDE_PROJECT_DIR` unvalidated, so in a
+    // Claude Code session rooted at a sub-workspace the bridge would anchor
+    // there while the writers anchored at the true root — the split-brain this
+    // module's own header warns about.
+    _projectRoot = resolveStateRoot();
     return _projectRoot;
 }
 import { ControllerRegistry } from './controller-registry.js';

package/dist/src/cli/memory/daemon-write-client.js

@@ -37,14 +37,14 @@
  * @module cli/memory/daemon-write-client
  */
 import * as http from 'node:http';
-import { findProjectRoot } from '../services/project-root.js';
+import { resolveStateRoot } from '../services/project-root.js';
 import { resolveClientPort, LEGACY_DEFAULT_PORT, probeDaemonHealth as probeDaemonHealthIdentity, normalizeProjectRoot, } from '../services/daemon-port.js';
 // ============================================================================
 // Constants
 // ============================================================================
 /**
  * Read-only legacy default exported for tests; the actual port comes from
- * `getDaemonPort()` which delegates to `resolveClientPort(findProjectRoot())`.
+ * `getDaemonPort()` which delegates to `resolveClientPort(resolveStateRoot())`.
  * Routes through `LEGACY_DEFAULT_PORT` so no literal port number lives in
  * this file — see `daemon-port.ts` and the no-fixed-port regression guard.
  */
@@ -72,7 +72,7 @@ export function _resetForTest() {
 /**
  * Resolve the daemon HTTP port for this project.
  *
- * Delegates to `resolveClientPort(findProjectRoot())`:
+ * Delegates to `resolveClientPort(resolveStateRoot())`:
  *   1. `MOFLO_DAEMON_PORT` env override (consumer pin)
  *   2. `port` field in `<projectRoot>/.moflo/daemon.lock` (server records
  *      the actual bound port after startup — #1145)
@@ -85,7 +85,7 @@ export function _resetForTest() {
  */
 let _portCache = null;
 function getDaemonPort() {
-    const projectRoot = findProjectRoot();
+    const projectRoot = resolveStateRoot();
     if (_portCache && _portCache.projectRoot === projectRoot)
         return _portCache.port;
     const port = resolveClientPort(projectRoot);
@@ -173,7 +173,7 @@ export async function isDaemonAvailable() {
  */
 async function isDaemonIdentityMatch(port) {
     const now = Date.now();
-    const ourProjectRoot = findProjectRoot();
+    const ourProjectRoot = resolveStateRoot();
     if (identityCache &&
         identityCache.ourProjectRoot === ourProjectRoot &&
         (now - identityCache.checkedAt) < HEALTH_CACHE_TTL_MS) {

package/dist/src/cli/memory/database-provider.js

@@ -11,6 +11,7 @@
 import { platform } from 'node:os';
 import { existsSync } from 'node:fs';
 import { SqliteBackend } from './sqlite-backend.js';
+import { resolveStateRoot } from '../services/project-root.js';
 /**
  * Canonical label returned in MCP `backend` fields and other consumer-visible
  * surfaces. Single source of truth so a future engine swap is a one-line edit
@@ -201,19 +202,27 @@ export function getPlatformInfo() {
  * Wrapped in a dynamic import so the memory subtree doesn't pull
  * `js-yaml` / `fs` into hot paths (e.g. the in-memory test backend).
  *
- * Memoised per (cwd, process) — a test suite or daemon that opens many
- * DBs in sequence parses moflo.yaml once. Keyed on cwd so a test that
- * `chdir`s into a temp dir gets a fresh resolution.
+ * Memoised per (resolved state root, process) — a test suite or daemon that
+ * opens many DBs in sequence parses moflo.yaml once. Keyed on the resolved
+ * root so a test that `chdir`s into a temp dir still gets a fresh resolution
+ * (an un-initialized temp dir resolves to itself).
+ *
+ * #1315 — this reads the BACKEND while the rest of the memory layer resolves
+ * the DB PATH. Both must anchor on the same root or they disagree: with the
+ * path fixed to `<root>/.moflo/moflo.db` but the config still read from cwd, a
+ * `flo` invocation from a sub-directory found no moflo.yaml, fell back to the
+ * DEFAULT backend, and opened the root's database with a different engine than
+ * the daemon was using it with.
  */
 const _resolvedProviderCache = new Map();
 async function preferredProviderFromConfig(verbose) {
-    const key = process.cwd();
+    const key = resolveStateRoot();
     if (_resolvedProviderCache.has(key)) {
         return _resolvedProviderCache.get(key) ?? null;
     }
     try {
         const { loadMofloConfig, resolveDatabaseProvider } = await import('../config/moflo-config.js');
-        const cfg = loadMofloConfig();
+        const cfg = loadMofloConfig(key);
         const resolved = resolveDatabaseProvider(cfg.memory.backend);
         if (verbose) {
             console.log(`[DatabaseProvider] moflo.yaml memory.backend="${cfg.memory.backend}" → ${resolved}`);

package/dist/src/cli/memory/entries-read.js

@@ -19,6 +19,7 @@ import { getBridge } from './bridge-loader.js';
 import { tryDaemonGet, tryDaemonSearch, tryDaemonList } from './daemon-write-client.js';
 import { searchCandidateCap } from './bridge-core.js';
 import { cosineSim, logRoutingFault } from './entries-shared.js';
+import { resolveStateRoot } from '../services/project-root.js';
 /**
  * Search entries via node:sqlite with vector similarity.
  * Uses HNSW approximate-nearest-neighbor (ANN) index for search when available.
@@ -65,7 +66,7 @@ export async function searchEntries(options) {
     }
     // Fallback: direct node:sqlite write via the unified factory.
     const { query, namespace = 'default', limit = 10, threshold = 0.3, dbPath: customPath } = options;
-    const dbPath = customPath || memoryDbPath(process.cwd());
+    const dbPath = customPath || memoryDbPath(resolveStateRoot());
     const startTime = Date.now();
     try {
         if (!fs.existsSync(dbPath)) {
@@ -186,7 +187,7 @@ export async function listEntries(options) {
     }
     // Fallback: direct node:sqlite write via the unified factory.
     const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;
-    const dbPath = customPath || memoryDbPath(process.cwd());
+    const dbPath = customPath || memoryDbPath(resolveStateRoot());
     try {
         if (!fs.existsSync(dbPath)) {
             return { success: false, entries: [], total: 0, error: 'Database not found' };
@@ -272,7 +273,7 @@ export async function getEntry(options) {
     }
     // Fallback: direct node:sqlite write via the unified factory.
     const { key, namespace = 'default', dbPath: customPath } = options;
-    const dbPath = customPath || memoryDbPath(process.cwd());
+    const dbPath = customPath || memoryDbPath(resolveStateRoot());
     try {
         if (!fs.existsSync(dbPath)) {
             return { success: false, found: false, error: 'Database not found' };
@@ -350,7 +351,7 @@ export async function getEntry(options) {
  * wrong-answer this fix is for.
  */
 export async function getNamespaceCounts(dbPath) {
-    const resolvedPath = dbPath || memoryDbPath(process.cwd());
+    const resolvedPath = dbPath || memoryDbPath(resolveStateRoot());
     if (!fs.existsSync(resolvedPath)) {
         return { namespaces: {}, total: 0, withEmbeddings: 0 };
     }

package/dist/src/cli/memory/entries-write.js

@@ -25,6 +25,7 @@ import { toFloat32 } from './controllers/_shared.js';
 import { serialiseMetadata } from './bridge-entries.js';
 import { logRoutingFault, writeVectorStatsCache } from './entries-shared.js';
 import { writeThroughDurable } from '../services/durable-sync.js';
+import { resolveStateRoot } from '../services/project-root.js';
 /**
  * Propagate a just-persisted durable write to the shared store (#1232). The
  * caller passes the project root the row actually landed under so the flush
@@ -139,7 +140,7 @@ export async function storeEntry(options) {
     }
     // Fallback: direct node:sqlite write via the unified factory.
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
-    const dbPath = customPath || memoryDbPath(process.cwd());
+    const dbPath = customPath || memoryDbPath(resolveStateRoot());
     try {
         if (!fs.existsSync(dbPath)) {
             return { success: false, id: '', error: 'Database not initialized. Run: flo memory init' };
@@ -362,7 +363,7 @@ export async function deleteEntry(options) {
     }
     // Fallback: direct node:sqlite write via the unified factory.
     const { key, namespace = 'default', dbPath: customPath } = options;
-    const dbPath = customPath || memoryDbPath(process.cwd());
+    const dbPath = customPath || memoryDbPath(resolveStateRoot());
     try {
         if (!fs.existsSync(dbPath)) {
             return {

package/dist/src/cli/memory/hnsw-singleton.js

@@ -20,6 +20,7 @@ import { parseEmbeddingJson } from './controllers/_shared.js';
 import { memoryDbPath } from '../services/moflo-paths.js';
 import { openDaemonDatabase } from './daemon-backend.js';
 import { getBridge, isBridgeLoaded } from './bridge-loader.js';
+import { resolveStateRoot } from '../services/project-root.js';
 let hnswIndex = null;
 let hnswInitializing = false;
 /**
@@ -44,7 +45,7 @@ export async function getHNSWIndex(options) {
     try {
         // Use HnswLite pure TS implementation (no native dependencies).
         // Persistent storage paths — colocated with the canonical memory DB.
-        const dbPath = options?.dbPath || memoryDbPath(process.cwd());
+        const dbPath = options?.dbPath || memoryDbPath(resolveStateRoot());
         const dbDir = path.dirname(dbPath);
         if (!fs.existsSync(dbDir)) {
             fs.mkdirSync(dbDir, { recursive: true });

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

@@ -15,6 +15,7 @@ import { MOFLO_DIR, legacyMemoryDbPath, memoryDbPath, } from '../services/moflo-
 import { openDaemonDatabase } from './daemon-backend.js';
 import { getBridge } from './bridge-loader.js';
 import { MEMORY_SCHEMA_V3, getInitialMetadata } from './schema.js';
+import { resolveStateRoot } from '../services/project-root.js';
 /**
  * Check for legacy database installations and migrate if needed
  */
@@ -25,12 +26,17 @@ export async function checkAndMigrateLegacy(options) {
     // probe still catches consumers whose launcher migration deferred. The
     // bare `memory.db` and `.claude/memory.db`/`data/memory.db` entries are
     // older still.
+    // #1315 — every probe anchors on the RESOLVED root, not cwd. These look for
+    // a pre-#727 database to migrate from, and that database lives at the
+    // project root; probing cwd meant a `flo` run from any sub-directory found
+    // nothing and silently skipped the migration.
+    const stateRoot = resolveStateRoot();
     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'),
+        legacyMemoryDbPath(stateRoot),
+        path.join(stateRoot, MOFLO_DIR, 'memory.db'),
+        path.join(stateRoot, 'memory.db'),
+        path.join(stateRoot, '.claude', 'memory.db'),
+        path.join(stateRoot, 'data', 'memory.db'),
     ];
     for (const legacyPath of legacyPaths) {
         if (fs.existsSync(legacyPath) && legacyPath !== dbPath) {
@@ -148,7 +154,7 @@ function unlinkWithRetry(filePath) {
  */
 export async function initializeMemoryDatabase(options) {
     const { backend = 'hybrid', dbPath: customPath, force = false, verbose = false, migrate = true } = options;
-    const dbPath = customPath || memoryDbPath(process.cwd());
+    const dbPath = customPath || memoryDbPath(resolveStateRoot());
     const dbDir = path.dirname(dbPath);
     try {
         // Create directory if needed
@@ -290,7 +296,7 @@ export async function initializeMemoryDatabase(options) {
  * Check if memory database is properly initialized
  */
 export async function checkMemoryInitialization(dbPath) {
-    const path_ = dbPath || memoryDbPath(process.cwd());
+    const path_ = dbPath || memoryDbPath(resolveStateRoot());
     if (!fs.existsSync(path_)) {
         return { initialized: false };
     }
@@ -334,7 +340,7 @@ export async function checkMemoryInitialization(dbPath) {
  * Reduces confidence of patterns that haven't been used recently
  */
 export async function applyTemporalDecay(dbPath) {
-    const path_ = dbPath || memoryDbPath(process.cwd());
+    const path_ = dbPath || memoryDbPath(resolveStateRoot());
     try {
         const db = openDaemonDatabase(path_);
         // Apply decay: confidence *= exp(-decay_rate * days_since_last_use)

package/dist/src/cli/memory/learnings-overview.js

@@ -18,6 +18,7 @@
 import * as fs from 'fs';
 import { memoryDbPath } from '../services/moflo-paths.js';
 import { openDaemonDatabase } from './daemon-backend.js';
+import { resolveStateRoot } from '../services/project-root.js';
 /** The namespace this overview is scoped to. */
 const LEARNINGS_NAMESPACE = 'learnings';
 /** Default number of most-recent learnings returned with their bodies. */
@@ -87,7 +88,7 @@ export async function getLearningsOverview(options) {
     // finite positive integer so a stray float/NaN/≤0 can't produce bad SQL.
     const recentLimit = toPositiveInt(options?.recentLimit, DEFAULT_RECENT_LIMIT);
     const bodyCap = toPositiveInt(options?.bodyCap, DEFAULT_BODY_CAP);
-    const resolvedPath = options?.dbPath || memoryDbPath(process.cwd());
+    const resolvedPath = options?.dbPath || memoryDbPath(resolveStateRoot());
     if (!fs.existsSync(resolvedPath)) {
         return { ...EMPTY };
     }

package/dist/src/cli/runtime/headless.js

@@ -18,6 +18,7 @@ import { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES } from '../services/headl
 import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
 import { attachSignalHandlers } from '../shared/resilience/signal-handlers.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { resolveStateRoot } from '../services/project-root.js';
 import { initializeIntelligence, benchmarkAdaptation, getIntelligenceStats } from '../memory/intelligence.js';
 import { getHNSWStatus, batchCosineSim, flashAttentionSearch } from '../memory/memory-initializer.js';
 import { readMofloEnv } from '../services/env-compat.js';
@@ -100,7 +101,10 @@ Examples:
  */
 async function runWorker(workerType, timeout) {
     console.log(`[Headless] Starting worker: ${workerType}`);
-    const executor = new HeadlessWorkerExecutor(process.cwd(), {
+    // #1315 — the HeadlessWorkerExecutor constructor unconditionally creates
+    // `<root>/.moflo/reports` and `<root>/.moflo/logs/headless`, so handing it
+    // raw cwd minted an island wherever the headless runtime happened to start.
+    const executor = new HeadlessWorkerExecutor(resolveStateRoot(), {
         maxConcurrent: 1,
         defaultTimeoutMs: timeout
     });
@@ -131,8 +135,9 @@ async function runWorker(workerType, timeout) {
  */
 async function runDaemon() {
     console.log('[Headless] Starting daemon mode...');
-    // Start the daemon
-    const daemon = await startDaemon(process.cwd());
+    // Start the daemon. #1315 — resolved root, not cwd: `startDaemon` builds a
+    // WorkerDaemon and that constructor creates the state dir it is handed.
+    const daemon = await startDaemon(resolveStateRoot());
     console.log('[Headless] Daemon started');
     console.log('[Headless] Press Ctrl+C to stop');
     attachSignalHandlers(async (sig) => {

package/dist/src/cli/services/daemon-dashboard.js

@@ -18,7 +18,7 @@ import { handleMemoryStore, handleMemoryDelete, handleMemoryBatch, handleMemoryG
 import { aggregateClaudeStats, emptyClaudeStatsShape } from './claude-stats.js';
 import { serverPortCandidates, LEGACY_DEFAULT_PORT } from './daemon-port.js';
 import { writeLockPort } from './daemon-lock.js';
-import { findProjectRoot } from './project-root.js';
+import { resolveStateRoot } from './project-root.js';
 import { readOwnMofloVersion } from './daemon-lock.js';
 /**
  * Legacy default port retained as a re-export of {@link LEGACY_DEFAULT_PORT}
@@ -144,7 +144,7 @@ function tryParseSafe(s) {
  * Build the `/api/health` response (#1145).
  *
  * Identity payload — clients compare `projectRoot` against their own
- * `findProjectRoot()` and refuse to route to this daemon on mismatch.
+ * `resolveStateRoot()` and refuse to route to this daemon on mismatch.
  * Also surfaces `pid`, `version`, and `uptimeMs` for healer-class
  * diagnostics and orphan-daemon detection.
  *
@@ -155,7 +155,7 @@ function handleHealth(daemon, opts) {
     const startedAt = status.startedAt instanceof Date ? status.startedAt : null;
     return {
         status: 'ok',
-        projectRoot: opts.projectRoot ?? findProjectRoot(),
+        projectRoot: opts.projectRoot ?? resolveStateRoot(),
         pid: status.pid ?? process.pid,
         version: readOwnMofloVersion() ?? null,
         uptimeMs: startedAt ? Date.now() - startedAt.getTime() : 0,
@@ -664,7 +664,7 @@ const MAX_PORT_ATTEMPTS = 10;
  * @returns handle whose `.port` field reflects the actually bound port
  */
 export async function startDashboard(daemon, opts) {
-    const projectRoot = opts.projectRoot ?? findProjectRoot();
+    const projectRoot = opts.projectRoot ?? resolveStateRoot();
     const candidates = buildBindCandidates(opts.port, projectRoot, MAX_PORT_ATTEMPTS);
     let lastErr = null;
     for (let i = 0; i < candidates.length; i++) {