moflo 4.9.10 → 4.9.11

package/.claude/skills/spell-schedule/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: spell-schedule
+description: |
+  Schedule a moflo spell to run on the local machine via the moflo daemon (cron, interval, or one-time).
+  Use when the user wants to schedule, automate, or recurringly run one of THEIR spells locally —
+  e.g. "schedule the oap spell every hour", "run my audit spell every weekday at 9am", "fire X once tomorrow morning".
+  This is the LOCAL daemon path. For remote Anthropic-cloud agents, use /schedule instead.
+arguments: "[spell-name-or-alias]"
+---
+
+# /spell-schedule — Schedule a Local Spell
+
+This skill walks the user through scheduling a moflo spell on the **local** moflo daemon.
+Schedules live in moflo's memory store and are evaluated once per minute by the daemon's poll loop.
+Execution goes through the same engine path as `flo spell cast`.
+
+> Not the same as `/schedule`. `/schedule` creates **remote** Anthropic-cloud routines; this skill drives the **local** daemon scheduler.
+
+**Arguments:** `$ARGUMENTS` (optional spell name/alias to pre-select)
+
+## When to use
+
+The user says any of:
+- "schedule the X spell"
+- "run X every <interval>"
+- "fire X once at <time>"
+- "set up a recurring run for X"
+- "I want X to run every morning"
+
+If the user wants a **cloud** agent (mentions "remote", "GitHub Actions", "Anthropic cloud", or specifies a repo to clone), redirect them to `/schedule`.
+
+## Workflow
+
+### Step 1 — Verify the daemon is running
+
+```bash
+npx flo doctor 2>&1 | grep -i daemon
+```
+
+If the daemon is not running, prompt the user:
+- "The moflo daemon isn't running. Schedules only fire while the daemon is up. Start it now?"
+- If yes: `npx flo daemon start` (or instruct them to enable OS autostart for survival across reboots).
+- If they decline, warn the user that the schedule will be created but won't fire until the daemon is started.
+
+### Step 2 — Identify the target spell
+
+If `$ARGUMENTS` was provided, use it as the spell name/alias. Otherwise, list spells and let the user pick:
+
+```bash
+npx flo spell list 2>&1
+```
+
+The output is a markdown table with columns: name, alias, description, source. Both `name` and `alias` are valid for `flo spell schedule create -n <value>` — prefer the full name to avoid alias conflicts.
+
+If the user-named spell is not in the list, stop and ask. Do NOT silently create a schedule for a missing spell — it will be auto-disabled on first fire.
+
+### Step 3 — Pick the cadence
+
+Use AskUserQuestion to offer four options:
+
+| Option | When to suggest | CLI form |
+|--------|-----------------|----------|
+| **Cron** | Specific time of day, day of week, or month boundary | `--cron "<5-field cron>"` (UTC, 5 fields: minute hour day-of-month month day-of-week) |
+| **Interval** | "Every N seconds/minutes/hours/days" with no specific clock anchor | `--interval <N><s\|m\|h\|d>` (e.g., `30m`, `6h`, `1d`) |
+| **One-time** | "Run once at..." or "remind me to..." | `--at <ISO 8601 datetime>` |
+| **Embedded in spell** | The schedule should travel with the spell definition (registered every daemon start) | Edit the spell YAML to add a `schedule:` block; no CLI |
+
+#### Timezone conversion (CRITICAL)
+
+Cron expressions and `--at` timestamps are **always UTC**. The user almost always means their local time.
+
+1. **Look up the user's timezone** — derive from system. On Windows, `[System.TimeZoneInfo]::Local.Id` or read the auto-memory `currentDate` block. **Never** guess.
+2. **Convert to UTC** explicitly using PowerShell (cross-platform-safe):
+   ```powershell
+   [System.TimeZoneInfo]::ConvertTimeToUtc((Get-Date "9:00am"), [System.TimeZoneInfo]::Local)
+   ```
+3. **Echo back the conversion**: "9am America/Guatemala = 15:00 UTC, so the cron would be `0 15 * * 1-5`. Confirm?"
+4. **Re-check current time before any `--at`** — long conversations drift. Run `date -u +%Y-%m-%dT%H:%M:%SZ` (or PowerShell equivalent) before computing the absolute timestamp. If the resolved time is in the past, ask for clarification — do not silently roll forward.
+
+#### Constraints
+
+- Minimum poll interval is 1 minute (the daemon polls once per `pollIntervalMs`, default 60000). Sub-minute schedules are rejected.
+- Interval units: `s`, `m`, `h`, `d` ONLY. `--interval 1w` is rejected at load time.
+- `--at` must be a valid ISO 8601 datetime in the future.
+- Exactly one of `--cron`, `--interval`, `--at` per schedule.
+
+### Step 4 — Confirm and create
+
+Show the full plan to the user before creating:
+
+```
+Spell:    outlook-attachment-processor (alias: oap)
+Cadence:  every weekday at 9am America/Guatemala (15:00 UTC)
+Cron:     0 15 * * 1-5
+Daemon:   running ✓
+```
+
+After user confirms, run:
+
+```bash
+npx flo spell schedule create -n <spell-name> --cron "<cron>" 2>&1
+# or --interval <value>
+# or --at <iso-datetime>
+```
+
+Capture the schedule ID from output and surface it to the user along with the next computed run time.
+
+### Step 5 — Verify the wiring
+
+Tail the schedule executions for the first fire so the user can confirm the daemon actually picks it up:
+
+```bash
+npx flo spell schedule list 2>&1
+```
+
+If the user wants to wait for the first fire (interval ≤ 5m), poll `flo spell schedule list` or the daemon dashboard. Otherwise, summarize and exit:
+
+```
+Scheduled: <schedule-id>
+Next run:  <ISO datetime UTC> (<local-equivalent>)
+Cancel:    npx flo spell schedule cancel <schedule-id>
+```
+
+## Sub-actions (when not creating)
+
+If the user asks to **list** schedules:
+```bash
+npx flo spell schedule list 2>&1
+```
+
+If the user asks to **cancel** a schedule:
+1. Run `flo spell schedule list` and let them pick.
+2. `npx flo spell schedule cancel <schedule-id>`.
+3. Confirm the entry is gone from the list.
+
+If the user asks to **run now** without altering the cadence:
+- Use the dashboard's "Run now" button if available, or the daemon's `runScheduleNow` API.
+- The CLI does not currently expose this — surface that limitation if asked, and offer `flo spell cast -n <name>` as a manual alternative.
+
+## Important — gotchas
+
+- **Daemon prerequisite**: schedules only fire while the daemon is running. Tell the user this explicitly. For survival across reboots, `flo daemon install` registers the OS-level autostart service.
+- **Catch-up window** (default 1h, `scheduler.catchUpWindowMs` in `moflo.yaml`): if the daemon was offline when a run was due, runs within the window still fire on the next poll. Older missed runs are skipped with a `schedule:skipped` event.
+- **maxConcurrent** (default 2): caps the number of scheduled spells running concurrently. Same-schedule overlap is never allowed.
+- **No update CLI yet**: `flo spell schedule` exposes create/list/cancel only. To change a cadence, cancel + recreate.
+- **Spell-required sandboxing** (#878): when that ships, scheduled runs honor it just like manual casts — a missing sandbox skips the run with a `schedule:skipped` event.
+
+## Output
+
+End the session with a single-block summary:
+
+```
+Schedule Created
+────────────────
+Spell:       <name>
+Cadence:     <human-readable>
+Cron/At:     <UTC expression>
+ID:          <schedule-id>
+Next run:    <UTC + local>
+Cancel:      npx flo spell schedule cancel <id>
+Daemon:      running | needs-start
+```
+
+## Reference
+
+- Full daemon scheduler docs: https://github.com/eric-cielo/moflo/blob/main/docs/SPELLS.md#scheduling
+- Tracking issue: https://github.com/eric-cielo/moflo/issues/877

package/bin/session-start-launcher.mjs

@@ -838,8 +838,11 @@ try {
       settingsChanges.push('added statusLine');
     }
 
-    // 3a-iv. Repair missing required hook wirings (same logic as doctor --fix
-    // and moflo upgrade — shared via hook-wiring.js to stay DRY)
+    // 3a-iv. Repair missing required hook wirings AND rewrite known-bad
+    // wirings from older moflo versions (#879 — record-memory-searched
+    // wired to gate.cjs directly skips session_id forwarding and deadlocks
+    // the per-actor gate). Both passes share hook-wiring.js so doctor --fix,
+    // upgrade-merge, and the launcher stay DRY.
     try {
       const hwPaths = [
         resolve(projectRoot, 'node_modules/moflo/dist/src/cli/services/hook-wiring.js'),
@@ -847,11 +850,21 @@ try {
       ];
       const hwPath = hwPaths.find(p => existsSync(p));
       if (hwPath) {
-        const { repairHookWiring } = await import(`file://${hwPath.replace(/\\/g, '/')}`);
-        const { repaired } = repairHookWiring(settings);
-        if (repaired.length > 0) {
-          dirty = true;
-          settingsChanges.push(`repaired ${plural(repaired.length, 'hook wiring')}`);
+        const mod = await import(`file://${hwPath.replace(/\\/g, '/')}`);
+        if (typeof mod.rewriteIncorrectHookWiring === 'function') {
+          const { rewrites } = mod.rewriteIncorrectHookWiring(settings);
+          if (rewrites.length > 0) {
+            dirty = true;
+            const total = rewrites.reduce((n, r) => n + r.count, 0);
+            settingsChanges.push(`rewrote ${plural(total, 'stale hook wiring')}`);
+          }
+        }
+        if (typeof mod.repairHookWiring === 'function') {
+          const { repaired } = mod.repairHookWiring(settings);
+          if (repaired.length > 0) {
+            dirty = true;
+            settingsChanges.push(`repaired ${plural(repaired.length, 'hook wiring')}`);
+          }
         }
       }
     } catch (err) {

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

package/package.json

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