moflo 4.9.9 → 4.9.11

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

@@ -1114,12 +1114,37 @@ function killTrackedProcesses() {
     catch { /* ok */ }
     return killed;
 }
+// Read the set of moflo background PIDs registered with the shared
+// ProcessManager (.moflo/background-pids.json). These are legitimate tracked
+// background tasks (sequential indexer chain, daemon, MCP servers spawned by
+// session-start) — they are detached:true by design so their parents have
+// already exited, but they are NOT orphans. Without this allow-set,
+// findZombieProcesses() flags every running indexer step as a zombie.
+function readTrackedBackgroundPids() {
+    const result = new Set();
+    const registryFile = join(process.cwd(), '.moflo', 'background-pids.json');
+    try {
+        if (!existsSync(registryFile))
+            return result;
+        const entries = JSON.parse(readFileSync(registryFile, 'utf-8'));
+        if (!Array.isArray(entries))
+            return result;
+        for (const entry of entries) {
+            if (entry && typeof entry.pid === 'number' && entry.pid > 0) {
+                result.add(entry.pid);
+            }
+        }
+    }
+    catch { /* malformed or unreadable — treat as empty */ }
+    return result;
+}
 // Find and optionally kill orphaned moflo/claude-flow node processes.
 // A process is only "orphaned" if its parent is no longer alive — meaning
 // nothing will clean it up. MCP servers spawned by a live Claude Code session
 // have a live parent (claude.exe) and must not be flagged.
 async function findZombieProcesses(kill = false) {
     const legitimatePid = getDaemonLockHolder(process.cwd());
+    const trackedPids = readTrackedBackgroundPids();
     const currentPid = process.pid;
     const parentPid = process.ppid;
     const found = [];
@@ -1161,6 +1186,11 @@ async function findZombieProcesses(kill = false) {
     for (const { pid, ppid } of candidates) {
         if (pid === currentPid || pid === parentPid || pid === legitimatePid)
             continue;
+        // Tracked background tasks (indexer chain, etc.) are detached:true so their
+        // parent is dead by design. The ProcessManager registry tells us they are
+        // legitimate, not orphaned.
+        if (trackedPids.has(pid))
+            continue;
         if (isProcessAlive(ppid))
             continue;
         // Defense-in-depth: detached daemons have dead parents by design.

package/dist/src/cli/index.js

@@ -11,6 +11,7 @@ import { suggestCommand } from './suggest.js';
 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 { VERSION } from './version.js';
 export { VERSION };
 const LONG_RUNNING_COMMANDS = ['mcp', 'daemon'];
@@ -461,6 +462,23 @@ export class CLI {
                 env: { ...process.env, CLAUDE_FLOW_DAEMON: '1' },
             });
         child.unref();
+        // Register the spawned daemon PID with the shared ProcessManager so that
+        // pm.killAll() (called by the session-end hook) can reap it, AND doctor's
+        // zombie scan recognises it as a tracked process rather than an orphan.
+        // Without this, every consumer's first `flo doctor` after a CLI command
+        // sees the auto-started daemon as a "zombie" because its parent (this
+        // CLI process) has already exited. SYNCHRONOUS — must complete before any
+        // concurrent doctor scan runs the registry read.
+        if (child.pid) {
+            try {
+                registerBackgroundPid(projectRoot, child.pid, 'daemon', spawnArgs.slice(1).join(' '));
+            }
+            catch {
+                // Registration is non-essential — daemon still works, just not visible
+                // to PM-aware tooling. Stay silent to keep maybeAutoStartDaemon a
+                // fire-and-forget helper.
+            }
+        }
     }
     /**
      * Load configuration file

package/dist/src/cli/init/moflo-init.js

@@ -498,8 +498,13 @@ function generateHooks(root, force, answers) {
                 "hooks": [{ "type": "command", "command": gateHook('record-skill-run'), "timeout": 2000 }]
             },
             {
+                // Use gateHook (not gate) so the wrapper forwards Claude Code's session_id as
+                // HOOK_SESSION_ID — record-memory-searched needs this to mark the per-actor map
+                // (memorySearchedBy[sid]) that check-before-read consults under #838's per-actor gating.
+                // Without it, the legacy boolean is set but the per-actor map stays empty, and the gate
+                // blocks every Read forever within the turn (issue #879).
                 "matcher": "mcp__moflo__memory_",
-                "hooks": [{ "type": "command", "command": gate('record-memory-searched'), "timeout": 3000 }]
+                "hooks": [{ "type": "command", "command": gateHook('record-memory-searched'), "timeout": 3000 }]
             },
             {
                 "matcher": "^mcp__moflo__memory_store$",
@@ -511,6 +516,14 @@ function generateHooks(root, force, answers) {
                 "hooks": [
                     { "type": "command", "command": `node "$CLAUDE_PROJECT_DIR/.claude/helpers/prompt-hook.mjs"`, "timeout": 3000 }
                 ]
+            },
+            {
+                // prompt-reminder is REQUIRED to reset memorySearched/memorySearchedBy on each
+                // new prompt and reclassify memoryRequired. Without it, gate state leaks across
+                // prompts. Separate hook entry so a prompt-hook.mjs exception doesn't skip the reset.
+                "hooks": [
+                    { "type": "command", "command": gateHook('prompt-reminder'), "timeout": 3000 }
+                ]
             }
         ],
         "SubagentStart": [

package/dist/src/cli/init/settings-generator.js

@@ -270,9 +270,14 @@ function generateHooksConfig(config) {
                 hooks: [{ type: 'command', command: gateHookCmd('record-skill-run'), timeout: 2000 }],
             },
             {
-                // Simplified matcher — anchored regex with parens doesn't match MCP tool names reliably
+                // Simplified matcher — anchored regex with parens doesn't match MCP tool names reliably.
+                // Use gateHookCmd (not gateCmd) so the wrapper forwards Claude Code's session_id as
+                // HOOK_SESSION_ID — record-memory-searched needs this to mark the per-actor map
+                // (memorySearchedBy[sid]) that check-before-read consults under #838's per-actor gating.
+                // Without it, the legacy boolean is set but the per-actor map stays empty, and the gate
+                // blocks every Read forever within the turn (issue #879).
                 matcher: 'mcp__moflo__memory_',
-                hooks: [{ type: 'command', command: gateCmd('record-memory-searched'), timeout: 3000 }],
+                hooks: [{ type: 'command', command: gateHookCmd('record-memory-searched'), timeout: 3000 }],
             },
             {
                 matcher: '^TaskUpdate$',
@@ -284,7 +289,12 @@ function generateHooksConfig(config) {
             },
         ];
     }
-    // UserPromptSubmit — gate reminders + intelligent task routing
+    // UserPromptSubmit — gate reminders + intelligent task routing.
+    // The prompt-reminder hook is REQUIRED — it resets memorySearched / memorySearchedBy
+    // and reclassifies memoryRequired from the new prompt. Without it, gate state leaks
+    // across prompts: a previous turn's "satisfied" state survives, OR a previous turn's
+    // "armed" state never clears. Two separate hook entries (not chained) so an exception
+    // in prompt-hook.mjs doesn't skip the reset.
     if (config.userPromptSubmit) {
         hooks.UserPromptSubmit = [
             {
@@ -292,6 +302,11 @@ function generateHooksConfig(config) {
                     { type: 'command', command: promptHookCmd(), timeout: 3000 },
                 ],
             },
+            {
+                hooks: [
+                    { type: 'command', command: gateHookCmd('prompt-reminder'), timeout: 3000 },
+                ],
+            },
         ];
     }
     // SubagentStart — inject directive for subagents to read guidance protocol

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

@@ -12,6 +12,7 @@ import { spawn } from 'child_process';
 import { getDaemonLockHolder } from './daemon-lock.js';
 import { isDaemonInstalled, installDaemonService } from './daemon-service.js';
 import { locateMofloCliBin } from './moflo-require.js';
+import { registerBackgroundPid } from './process-registry.js';
 /**
  * Ensure the daemon is ready for scheduled spell execution.
  *
@@ -115,6 +116,17 @@ async function defaultStartDaemon(projectRoot) {
                 env: daemonEnv,
             });
         child.unref();
+        // Register the spawned daemon PID with the shared ProcessManager (parity
+        // with src/cli/index.ts maybeAutoStartDaemon). Without this, doctor's
+        // zombie scan flags this detached process as orphaned because its parent
+        // (this CLI invocation) exits as soon as ensureDaemonForScheduling
+        // resolves.
+        if (child.pid) {
+            try {
+                registerBackgroundPid(projectRoot, child.pid, 'daemon', spawnArgs.slice(1).join(' '));
+            }
+            catch { /* registration is non-essential */ }
+        }
         // Poll for daemon lock acquisition (up to 2s, checking every 200ms)
         for (let i = 0; i < 10; i++) {
             await new Promise(r => setTimeout(r, 200));

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

@@ -38,7 +38,10 @@ export const HOOK_ENTRY_MAP = {
     '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 } },
     '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': { event: 'PostToolUse', matcher: 'mcp__moflo__memory_', hook: { type: 'command', command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" record-memory-searched', timeout: 3000 } },
+    // 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
+    // markMemorySearched needs to stamp the per-actor map (#879).
+    'record-memory-searched': { event: 'PostToolUse', matcher: 'mcp__moflo__memory_', 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 } },
@@ -84,4 +87,54 @@ export function repairHookWiring(settings) {
     settings.hooks = hooks;
     return { settings, repaired };
 }
+export const HOOK_REWRITE_RULES = [
+    // Issue #879 — record-memory-searched MUST use gate-hook.mjs so Claude Code's
+    // session_id is forwarded as HOOK_SESSION_ID. Without it, the per-actor map
+    // stays empty and the gate blocks every Read forever within a turn.
+    {
+        name: '#879: record-memory-searched → gate-hook.mjs',
+        from: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" record-memory-searched',
+        to: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" record-memory-searched',
+    },
+    // Symmetry hardening — same fix shape for check-bash-memory. The shipped
+    // settings.json already wires this through gate-hook.mjs in current versions,
+    // but a stale consumer settings.json may have it wrong.
+    {
+        name: '#879: check-bash-memory → gate-hook.mjs',
+        from: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs" check-bash-memory',
+        to: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs" check-bash-memory',
+    },
+];
+/**
+ * Apply HOOK_REWRITE_RULES to every hook command in `settings.hooks.*`.
+ * Idempotent: a hook already at the `to` form won't match `from`.
+ *
+ * @returns The (potentially mutated) settings and a list of rewrites that fired.
+ */
+export function rewriteIncorrectHookWiring(settings) {
+    const hooks = (settings.hooks ?? {});
+    const rewrites = [];
+    for (const rule of HOOK_REWRITE_RULES) {
+        let count = 0;
+        for (const eventName of Object.keys(hooks)) {
+            const eventArray = hooks[eventName];
+            if (!Array.isArray(eventArray))
+                continue;
+            for (const block of eventArray) {
+                const blockHooks = block.hooks;
+                if (!Array.isArray(blockHooks))
+                    continue;
+                for (const h of blockHooks) {
+                    if (typeof h.command === 'string' && h.command.includes(rule.from)) {
+                        h.command = h.command.split(rule.from).join(rule.to);
+                        count++;
+                    }
+                }
+            }
+        }
+        if (count > 0)
+            rewrites.push({ name: rule.name, count });
+    }
+    return { settings, rewrites };
+}
 //# sourceMappingURL=hook-wiring.js.map

package/dist/src/cli/services/process-registry.js

@@ -0,0 +1,58 @@
+/**
+ * Shared write side of the moflo background-process registry.
+ *
+ * Mirrors `bin/lib/process-manager.mjs`'s atomic write logic so TS spawn
+ * sites (auto-start daemon in src/cli/index.ts and daemon-readiness.ts) can
+ * register their PIDs alongside the ones written by bin/hooks.mjs's
+ * spawnWindowless helper. Without registry parity, doctor's zombie scan
+ * (src/cli/commands/doctor.ts) flags every TS-spawned background process as
+ * an orphan, because they are detached:true so their immediate parent dies.
+ *
+ * The .mjs module remains the canonical reader/writer with full read+killAll
+ * semantics; this TS helper only covers the registration we need from compiled
+ * paths. Both write to the same JSON file (`<projectRoot>/.moflo/background-pids.json`),
+ * so a process registered here is reapable via pm.killAll() at session-end.
+ */
+import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'fs';
+const REGISTRY_FILENAME = 'background-pids.json';
+function registryPath(projectRoot) {
+    return join(projectRoot, '.moflo', REGISTRY_FILENAME);
+}
+function readRegistry(projectRoot) {
+    const path = registryPath(projectRoot);
+    if (!existsSync(path))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeRegistry(projectRoot, entries) {
+    const path = registryPath(projectRoot);
+    mkdirSync(join(projectRoot, '.moflo'), { recursive: true });
+    const tmp = `${path}.tmp.${process.pid}`;
+    writeFileSync(tmp, JSON.stringify(entries, null, 2));
+    renameSync(tmp, path);
+}
+/**
+ * Register a spawned background PID under the given label. Replaces any
+ * pre-existing entry with the same label so a stale dead-PID row doesn't
+ * accumulate when a daemon crashes and is restarted.
+ */
+export function registerBackgroundPid(projectRoot, pid, label, cmd) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return;
+    const fresh = readRegistry(projectRoot).filter(e => e && e.label !== label);
+    fresh.push({
+        pid,
+        label,
+        cmd: cmd.slice(0, 200),
+        startedAt: new Date().toISOString(),
+    });
+    writeRegistry(projectRoot, fresh);
+}
+//# sourceMappingURL=process-registry.js.map

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.9.9';
+export const VERSION = '4.9.11';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.9.9",
+  "version": "4.9.11",
   "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",
@@ -81,7 +81,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.9.8",
+    "moflo": "^4.9.10",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"