moflo 4.10.11 → 4.10.13

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

@@ -21,6 +21,7 @@
  */
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { findProjectRoot } from './project-root.js';
 export const MOFLO_DIR = '.moflo';
 /** Canonical memory DB filename (post-#727). Lives at `<root>/.moflo/moflo.db`. */
 export const MEMORY_DB_FILE = 'moflo.db';
@@ -68,6 +69,25 @@ export function legacyHnswIndexPath(projectRoot) {
 export function legacyMemoryDbBakPath(projectRoot) {
     return join(projectRoot, LEGACY_SWARM_DIR, `${LEGACY_MEMORY_DB_FILE}${LEGACY_MEMORY_DB_BAK_SUFFIX}`);
 }
+/**
+ * Resolve a runtime-state path under `.moflo/<subdir>/<filename>` at the
+ * project root. Lazy by design — every call routes through `findProjectRoot()`
+ * so the path never bakes in `process.cwd()` at module-load time (#1168 bug
+ * class). Use this for any persisted runtime state the daemon, MCP server,
+ * or neural runtime writes (weights, fisher matrix, routing patterns, etc.).
+ */
+export function runtimePath(subdir, filename) {
+    return join(mofloDir(findProjectRoot()), subdir, filename);
+}
+/**
+ * Legacy `.swarm/<filename>` path at the project root. Read-only fallback for
+ * consumers who saved state under the pre-#1168 location; never written by
+ * production code (enforced by the drift-guard in
+ * `published-package-drift-guard.test.ts`).
+ */
+export function legacySwarmPath(filename) {
+    return join(findProjectRoot(), LEGACY_SWARM_DIR, filename);
+}
 /**
  * Memory-DB probe order used by every reader that does best-effort detection
  * (statusline, doctor, swarm status, hooks aggregator). Canonical first so
@@ -84,4 +104,20 @@ export function memoryDbCandidatePaths(projectRoot) {
         join(projectRoot, '.claude', LEGACY_MEMORY_DB_FILE),
     ];
 }
+/**
+ * Common skip-list for any walk that enumerates a project's children looking
+ * for moflo state. Shared by `bin/session-start-launcher.mjs` (depth-1 walk)
+ * and `doctor-checks-config.ts` (depth-5 BFS) so the two can't silently
+ * diverge.
+ *
+ * Twin of `bin/lib/moflo-paths.mjs:COMMON_WALK_SKIP_NAMES`. Matched
+ * case-insensitively at every call site — Windows NTFS + macOS APFS are
+ * case-insensitive by default.
+ */
+export const COMMON_WALK_SKIP_NAMES = new Set([
+    'node_modules', '.git', '.svn', '.hg',
+    'dist', 'build', 'out', 'target', '.next', '.nuxt', '.cache',
+    'coverage', '.idea', '.vscode', '.turbo', '.svelte-kit',
+    'vendor', '__pycache__', '.venv', 'venv', '.tox',
+]);
 //# sourceMappingURL=moflo-paths.js.map

package/dist/src/cli/services/project-root.js

@@ -8,32 +8,73 @@
  * resolve through this single algorithm or its JS twin — otherwise different
  * writers land on different DBs and the bridge reads stale data.
  *
- * Algorithm (#1057) — two-pass walk so memory markers always win:
+ * Algorithm (#1057, #1174) — three-pass walk so memory markers always win
+ * across the ENTIRE ancestor chain (not just at the first level they appear):
  *   1. `process.env.CLAUDE_PROJECT_DIR`, if set (Claude Code / explicit override).
- *   2. **High-priority pass.** Walk from `opts.cwd ?? process.cwd()` up to the
- *      filesystem root, looking at each level for (in order):
- *        a. `<dir>/.moflo/moflo.db`            — canonical memory DB marker
- *        b. `<dir>/.swarm/memory.db`           — legacy memory DB marker (pre-#727)
- *        c. `<dir>/CLAUDE.md` AND `<dir>/package.json` — project marker pair
- *      If anything matches, return that dir. `node_modules` segments are
- *      skipped (npx run can land cwd inside one).
- *   3. **Low-priority pass.** Walk again from cwd up to root looking for:
- *        d. `<dir>/package.json`               — generic project marker
- *        e. `<dir>/.git`                       — git repo marker
- *      Return the first match.
- *   4. Fall back to `opts.cwd ?? process.cwd()`.
+ *   2. **Pass A — memory markers (topmost wins).** Walk from
+ *      `opts.cwd ?? process.cwd()` up to the filesystem root, collecting EVERY
+ *      level that has `.moflo/moflo.db` OR `.swarm/memory.db`. Return the
+ *      topmost (highest ancestor) match. This is the #1174 fix — pre-#1174 the
+ *      walk stopped at the nearest hit, fragmenting monorepos into daemon
+ *      islands.
+ *   3. **Pass B — project marker pair (nearest wins).** Only reached when no
+ *      moflo state exists anywhere up the tree. Walk again looking for
+ *      `<dir>/CLAUDE.md` AND `<dir>/package.json` at the same level; return
+ *      the nearest match.
+ *   4. **Pass C — bare project markers (nearest wins).** Walk again looking
+ *      for `<dir>/package.json` OR `<dir>/.git`; return the nearest match.
+ *   5. Fall back to `opts.cwd ?? process.cwd()`.
  *
- * Why two passes? An upstream `.moflo/moflo.db` MUST win over a nested
- * `package.json` (monorepo sub-package case) — otherwise the writer lands on
- * a different DB than the bridge. Doing it in a single pass with bare
- * `package.json` as a per-level marker would short-circuit at the nearest
- * package.json before ever seeing the upstream memory marker.
+ * `node_modules` segments are always skipped (npx run can land cwd inside one).
+ *
+ * Why topmost (Pass A)? When a monorepo has nested `.moflo/moflo.db` directories
+ * — typically because `flo init` was run from a subworkspace before #1174 — the
+ * MCP server, daemon, CLI, and gate hooks ALL must agree on a single anchor.
+ * Topmost wins means the root daemon is canonical; sub-daemons become
+ * detectable residue that `flo doctor --fix` archives. Nearest-wins fragments
+ * state silently because every cwd resolves to a different anchor.
+ *
+ * Why nearest (Pass B/C)? Pass B/C only fires when there's no moflo state at
+ * all. In a fresh checkout the user expects `flo init` to anchor at the
+ * project they're in, not at some ancestor `.git`/`package.json` directory.
  *
  * Story #229 history: this function was first extracted from workflow-tools.ts;
- * #1057 brought it into alignment with bridge-core.getProjectRoot().
+ * #1057 brought it into alignment with bridge-core.getProjectRoot(); #1174
+ * changed Pass A from nearest-wins to topmost-wins to fix monorepo daemon
+ * fragmentation.
  */
 import { existsSync } from 'node:fs';
 import { resolve, dirname, parse, join, basename } from 'node:path';
+/**
+ * Walk strictly upward from `dir` (exclusive) and return the nearest ancestor
+ * that has `.moflo/moflo.db`, or `null` if none exists below the filesystem
+ * root.
+ *
+ * Used by `flo init` and the session-start launcher to detect nested-.moflo
+ * situations (#1174). Post-resolver-fix `findProjectRoot` returns the topmost
+ * memory marker, so encountering an ancestor here means either:
+ *   1. `CLAUDE_PROJECT_DIR` explicitly overrode to a sub-directory
+ *      (legitimate user action — log a warning but don't refuse), or
+ *   2. The caller is operating on a directory that's about to become a new
+ *      nested .moflo/ island (e.g. `flo init` in a sub-workspace).
+ *
+ * Algorithmic twin of `bin/lib/moflo-paths.mjs:findAncestorMofloRoot()`.
+ */
+export function findAncestorMofloRoot(dir) {
+    const start = resolve(dir);
+    const fsRoot = parse(start).root;
+    let cursor = dirname(start);
+    while (cursor !== fsRoot) {
+        if (existsSync(join(cursor, '.moflo', 'moflo.db'))) {
+            return cursor;
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    return null;
+}
 export function findProjectRoot(opts) {
     const honorEnv = opts?.honorEnv !== false;
     if (honorEnv && process.env.CLAUDE_PROJECT_DIR) {
@@ -42,17 +83,35 @@ export function findProjectRoot(opts) {
     const startDir = opts?.cwd ?? process.cwd();
     const start = resolve(startDir);
     const fsRoot = parse(start).root;
-    // High-priority pass: memory markers + CLAUDE.md/package.json pair.
+    // Pass A — memory markers, topmost wins (#1174).
+    // Collect every ancestor with `.moflo/moflo.db` or `.swarm/memory.db`, then
+    // return the highest one. Guarantees the root daemon is canonical in a
+    // monorepo with nested .moflo/ residue.
+    let topmostMemoryMarker = null;
     let dir = start;
     while (dir !== fsRoot) {
         if (basename(dir) === 'node_modules') {
             dir = dirname(dir);
             continue;
         }
-        if (existsSync(join(dir, '.moflo', 'moflo.db')))
-            return dir;
-        if (existsSync(join(dir, '.swarm', 'memory.db')))
-            return dir;
+        if (existsSync(join(dir, '.moflo', 'moflo.db')) || existsSync(join(dir, '.swarm', 'memory.db'))) {
+            topmostMemoryMarker = dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    if (topmostMemoryMarker)
+        return topmostMemoryMarker;
+    // Pass B — project marker pair, nearest wins. Only reached when no moflo
+    // state exists anywhere up the tree.
+    dir = start;
+    while (dir !== fsRoot) {
+        if (basename(dir) === 'node_modules') {
+            dir = dirname(dir);
+            continue;
+        }
         if (existsSync(join(dir, 'CLAUDE.md')) && existsSync(join(dir, 'package.json'))) {
             return dir;
         }
@@ -61,7 +120,7 @@ export function findProjectRoot(opts) {
             break;
         dir = parent;
     }
-    // Low-priority pass: bare package.json or .git.
+    // Pass C — bare package.json or .git, nearest wins.
     dir = start;
     while (dir !== fsRoot) {
         if (basename(dir) === 'node_modules') {

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.10.11';
+export const VERSION = '4.10.13';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.10.11",
+  "version": "4.10.13",
   "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",
@@ -95,7 +95,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.10.10",
+    "moflo": "^4.10.12",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"