moflo 4.10.12 → 4.10.13

package/dist/src/cli/mcp-server.js

@@ -62,6 +62,56 @@ function buildDefaultOptions() {
         daemonize: false,
     };
 }
+/**
+ * Best-effort append to the MCP log file. Errors are swallowed — logging must
+ * never crash the MCP server. Used to capture server start, project root
+ * resolution, and per-request timing so we never repeat the 18-hour
+ * diagnostic blind window from #1174.
+ *
+ * Rotation: when the log exceeds {@link MCP_LOG_ROTATE_BYTES}, rename it to
+ * `<logFile>.1` (overwriting any previous rotated file). One rotation level
+ * keeps the most recent ~50MB of activity plus the previous ~50MB. A long-
+ * running session with heavy MCP traffic can otherwise write hundreds of MB.
+ *
+ * Cross-platform: uses fs.appendFileSync + fs.mkdirSync({recursive:true}) +
+ * fs.renameSync. All three work identically on Windows/macOS/Linux. Windows
+ * note: renameSync can fail with EBUSY if the file is open by another
+ * process; we use append-only here so no other writer should hold it, but
+ * the rename is wrapped in a try/catch so a transient rotation failure can't
+ * crash the MCP server (next append succeeds; rotation retries next time).
+ */
+const MCP_LOG_ROTATE_BYTES = 50 * 1024 * 1024;
+// Throttle rotation checks: batch spell scenarios can write thousands of
+// MCP requests per session. statSync per append is wasted syscalls — bucket
+// the check every N writes (and always on the very first call so cold-start
+// rotation still fires).
+const MCP_LOG_ROTATE_CHECK_EVERY = 100;
+let mcpAppendsSinceRotateCheck = MCP_LOG_ROTATE_CHECK_EVERY;
+function safeAppendMcpLog(logFile, event) {
+    try {
+        fs.mkdirSync(path.dirname(logFile), { recursive: true });
+        // Rotate before append so the very write that crosses the threshold
+        // lands in the fresh file rather than the rotated one.
+        if (++mcpAppendsSinceRotateCheck >= MCP_LOG_ROTATE_CHECK_EVERY) {
+            mcpAppendsSinceRotateCheck = 0;
+            try {
+                const stats = fs.statSync(logFile);
+                if (stats.size >= MCP_LOG_ROTATE_BYTES) {
+                    const rotated = `${logFile}.1`;
+                    try {
+                        fs.unlinkSync(rotated);
+                    }
+                    catch { /* may not exist */ }
+                    fs.renameSync(logFile, rotated);
+                }
+            }
+            catch { /* file may not exist yet; first write creates it */ }
+        }
+        const line = JSON.stringify({ ts: new Date().toISOString(), ...event }) + '\n';
+        fs.appendFileSync(logFile, line, 'utf-8');
+    }
+    catch { /* logging must never throw */ }
+}
 /**
  * MCP Server Manager
  *
@@ -253,6 +303,27 @@ export class MCPServerManager extends EventEmitter {
             sessionId,
             version: VERSION,
         }));
+        // Persistent log (#1174). The MCP server previously logged only to stderr,
+        // which Claude Code drops on the floor unless the user runs `claude
+        // --debug`. The 18-hour daemon-island incident took that long to diagnose
+        // partly because no on-disk log captured server start, the resolved
+        // project root, or the request stream. Default-on JSONL log fixes that.
+        const resolvedProjectRoot = findProjectRoot();
+        safeAppendMcpLog(this.options.logFile, {
+            event: 'server.start',
+            sessionId,
+            version: VERSION,
+            pid: process.pid,
+            ppid: process.ppid,
+            platform: process.platform,
+            arch: process.arch,
+            nodeVersion: process.version,
+            cwd: process.cwd(),
+            projectRoot: resolvedProjectRoot,
+            claudeProjectDir: process.env.CLAUDE_PROJECT_DIR || null,
+            pidFile: this.options.pidFile,
+            logFile: this.options.logFile,
+        });
         // Send server initialization notification
         console.log(JSON.stringify({
             jsonrpc: '2.0',
@@ -380,8 +451,16 @@ export class MCPServerManager extends EventEmitter {
                             },
                         },
                     };
-                case 'tools/list':
+                case 'tools/list': {
+                    const listStart = performance.now();
                     const tools = listMCPTools();
+                    const durationMs = performance.now() - listStart;
+                    safeAppendMcpLog(this.options.logFile, {
+                        event: 'tools/list',
+                        sessionId,
+                        count: tools.length,
+                        durationMs: Math.round(durationMs * 100) / 100,
+                    });
                     return {
                         jsonrpc: '2.0',
                         id: message.id,
@@ -393,18 +472,32 @@ export class MCPServerManager extends EventEmitter {
                             })),
                         },
                     };
-                case 'tools/call':
+                }
+                case 'tools/call': {
                     const toolName = params.name;
                     const toolParams = (params.arguments || {});
                     if (!hasTool(toolName)) {
+                        safeAppendMcpLog(this.options.logFile, {
+                            event: 'tools/call.unknown',
+                            sessionId,
+                            toolName,
+                        });
                         return {
                             jsonrpc: '2.0',
                             id: message.id,
                             error: { code: -32601, message: `Tool not found: ${toolName}` },
                         };
                     }
+                    const callStart = performance.now();
                     try {
                         const result = await callMCPTool(toolName, toolParams, { sessionId });
+                        const durationMs = performance.now() - callStart;
+                        safeAppendMcpLog(this.options.logFile, {
+                            event: 'tools/call.ok',
+                            sessionId,
+                            toolName,
+                            durationMs: Math.round(durationMs * 100) / 100,
+                        });
                         return {
                             jsonrpc: '2.0',
                             id: message.id,
@@ -412,6 +505,14 @@ export class MCPServerManager extends EventEmitter {
                         };
                     }
                     catch (error) {
+                        const durationMs = performance.now() - callStart;
+                        safeAppendMcpLog(this.options.logFile, {
+                            event: 'tools/call.error',
+                            sessionId,
+                            toolName,
+                            durationMs: Math.round(durationMs * 100) / 100,
+                            error: error instanceof Error ? error.message : 'Tool execution failed',
+                        });
                         return {
                             jsonrpc: '2.0',
                             id: message.id,
@@ -421,6 +522,7 @@ export class MCPServerManager extends EventEmitter {
                             },
                         };
                     }
+                }
                 case 'notifications/initialized':
                     // Client notification - no response needed
                     console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Client initialized`);

package/dist/src/cli/services/hook-block-hash.js

@@ -56,7 +56,9 @@ export function getReferenceHookBlock() {
             { matcher: '^(Glob|Grep)$', hooks: [gateHook('check-before-scan', 3000)] },
             { matcher: '^Read$', hooks: [gateHook('check-before-read', 3000)] },
             {
-                matcher: '^Bash$',
+                // #1171 — widened to cover `PowerShell` tool; without this PS-tool
+                // calls bypass the dangerous/pr/memory gates on Windows.
+                matcher: '^(Bash|PowerShell)$',
                 hooks: [
                     gateHook('check-dangerous-command', 2000),
                     gateHook('check-before-pr', 2000),
@@ -78,7 +80,8 @@ export function getReferenceHookBlock() {
             { matcher: '^TaskCreate$', hooks: [gateCjs('record-task-created', 2000)] },
             {
                 // #1132 — check-bash-memory moved to PreToolUse (above).
-                matcher: '^Bash$',
+                // #1171 — widened to cover `PowerShell` tool.
+                matcher: '^(Bash|PowerShell)$',
                 hooks: [gateHook('record-test-run', 2000)],
             },
             { matcher: '^Skill$', hooks: [gateHook('record-skill-run', 2000)] },

package/dist/src/cli/services/hook-wiring.js

@@ -45,8 +45,10 @@ export const REQUIRED_HOOK_WIRING = [
 export const HOOK_ENTRY_MAP = {
     'check-before-scan': { event: 'PreToolUse', matcher: '^(Glob|Grep)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-before-scan', timeout: 3000 } },
     'check-before-read': { event: 'PreToolUse', matcher: '^Read$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-before-read', timeout: 3000 } },
-    'check-dangerous-command': { event: 'PreToolUse', matcher: '^Bash$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-dangerous-command', timeout: 2000 } },
-    'check-before-pr': { event: 'PreToolUse', matcher: '^Bash$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-before-pr', timeout: 2000 } },
+    // #1171 — matchers widened to cover `PowerShell` tool; the gate logic was
+    // always shell-agnostic but the matcher was Bash-anchored, leaving a bypass.
+    'check-dangerous-command': { event: 'PreToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-dangerous-command', timeout: 2000 } },
+    'check-before-pr': { event: 'PreToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-before-pr', timeout: 2000 } },
     'record-task-created': { event: 'PostToolUse', matcher: '^TaskCreate$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" record-task-created', timeout: 2000 } },
     // record-memory-searched MUST go through gate-hook.mjs (not gate.cjs directly)
     // — the wrapper forwards Claude Code's session_id as HOOK_SESSION_ID, which
@@ -58,8 +60,10 @@ export const HOOK_ENTRY_MAP = {
     'record-memory-searched': { event: 'PostToolUse', matcher: '^mcp__moflo__memory_(search|retrieve|list|stats|store)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" record-memory-searched', timeout: 3000 } },
     'check-task-transition': { event: 'PostToolUse', matcher: '^TaskUpdate$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" check-task-transition', timeout: 2000 } },
     'record-learnings-stored': { event: 'PostToolUse', matcher: '^mcp__moflo__memory_store$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" record-learnings-stored', timeout: 2000 } },
-    'check-bash-memory': { event: 'PostToolUse', matcher: '^Bash$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-bash-memory', timeout: 2000 } },
-    'record-test-run': { event: 'PostToolUse', matcher: '^Bash$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" record-test-run', timeout: 2000 } },
+    // #1171 — widened to ^(Bash|PowerShell)$ so PS reads / PS-invoked tests credit
+    // the same gates as Bash. Name kept as `check-bash-memory` for backwards compat.
+    'check-bash-memory': { event: 'PostToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-bash-memory', timeout: 2000 } },
+    'record-test-run': { event: 'PostToolUse', matcher: '^(Bash|PowerShell)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" record-test-run', timeout: 2000 } },
     'record-skill-run': { event: 'PostToolUse', matcher: '^Skill$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" record-skill-run', timeout: 2000 } },
     'reset-edit-gates': { event: 'PostToolUse', matcher: '^(Write|Edit|MultiEdit)$', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" reset-edit-gates', timeout: 2000 } },
     // #931 — Agent-time advisory; never blocks. Pulled the TaskCreate REMINDER
@@ -165,6 +169,36 @@ export const MATCHER_REWRITE_RULES = [
         to: '^mcp__moflo__memory_(search|retrieve|list|stats|store)$',
         cmdContains: 'record-memory-searched',
     },
+    // Issue #1171 — widen Bash-only matchers to cover the dedicated `PowerShell`
+    // tool Claude Code exposes on Windows. The gate logic itself was already
+    // shell-agnostic (gate.cjs READ_LIKE_BASH_RE matched `Get-Content`/`Select-String`/etc.)
+    // but a Bash-anchored matcher meant PS-tool calls never reached the gate.
+    // One rewrite per gate command keeps the `cmdContains` guard precise, so an
+    // unrelated user-customised `^Bash$` block doesn't get widened.
+    {
+        name: '#1171: widen check-dangerous-command matcher to PowerShell',
+        from: '^Bash$',
+        to: '^(Bash|PowerShell)$',
+        cmdContains: 'check-dangerous-command',
+    },
+    {
+        name: '#1171: widen check-before-pr matcher to PowerShell',
+        from: '^Bash$',
+        to: '^(Bash|PowerShell)$',
+        cmdContains: 'check-before-pr',
+    },
+    {
+        name: '#1171: widen check-bash-memory matcher to PowerShell',
+        from: '^Bash$',
+        to: '^(Bash|PowerShell)$',
+        cmdContains: 'check-bash-memory',
+    },
+    {
+        name: '#1171: widen record-test-run matcher to PowerShell',
+        from: '^Bash$',
+        to: '^(Bash|PowerShell)$',
+        cmdContains: 'record-test-run',
+    },
 ];
 /**
  * Apply HOOK_REWRITE_RULES to every hook command in `settings.hooks.*`.

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.10.12",
+  "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.11",
+    "moflo": "^4.10.12",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"