moflo 4.10.2 → 4.10.3

package/bin/session-start-launcher.mjs

@@ -358,10 +358,67 @@ function fireAndForget(cmd, args, label) {
   }
 }
 
+// Cross-platform sync sleep — Atomics.wait parks the thread at the OS level
+// without burning CPU (same primitive as src/cli/shared/utils/atomic-file-
+// write.ts:131). Used by stopDaemon's liveness polling between graceful and
+// forced termination so we never unlink the lockfile while the daemon is
+// still running.
+const STOP_SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
+function sleepSyncMs(ms) {
+  Atomics.wait(STOP_SLEEP_BUF, 0, 0, ms);
+}
+
+// PID liveness check. EPERM means the process exists but is owned by another
+// user — treat as alive (matches the canonical isAlive in process-manager.mjs
+// after #1061; the prior `catch { return false; }` falsely reported foreign-
+// owned daemons as dead and let the lockfile be unlinked under them).
+//
+// Linux zombie handling: on Linux, `kill(pid, 0)` returns success for zombie
+// processes (exited but not yet reaped by their parent). A zombie can't write
+// to the DB, hold locks, or do anything else stopDaemon cares about — treating
+// it as alive exhausts the kill budget polling a corpse, then preserves the
+// lockfile under a dead process. Production never hits this (the daemon is
+// detached and reaped by init/systemd within ~ms), but a misbehaving parent
+// can keep a daemon zombified, and the launcher's vitest harness reproduces
+// the case deterministically (#1083 CI failure on ubuntu-latest). Read
+// /proc/<pid>/stat (fixed-format, cheap) and treat 'Z' as dead.
+function isDaemonPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+  } catch (err) {
+    return err && err.code === 'EPERM';
+  }
+  if (process.platform === 'linux') {
+    try {
+      const stat = readFileSync(`/proc/${pid}/stat`, 'utf-8');
+      // Format: "pid (comm) state ..." — comm can contain spaces/parens, so
+      // parse from the LAST ')' to skip it safely.
+      const lastParen = stat.lastIndexOf(')');
+      if (lastParen !== -1 && stat.charAt(lastParen + 2) === 'Z') return false;
+    } catch (err) {
+      // ENOENT = pid vanished between kill(0) and the read — already dead.
+      if (err && err.code === 'ENOENT') return false;
+      // Anything else (e.g. /proc unavailable) — keep the kill(0) verdict.
+    }
+  }
+  return true;
+}
+
 // Stop the daemon recorded in `lockFile` (if any) without restarting. Used by
 // the upgrade flow before any DB work — the daemon must not be holding old
 // path resolution in memory, and a concurrent sql.js flush would clobber the
-// cherry-picked rows. Returns true when a live PID was actually killed.
+// cherry-picked rows. Returns true when a live PID was confirmed dead (or the
+// PID was already gone when we read the lockfile).
+//
+// Escalation mirrors src/cli/commands/daemon.ts:killBackgroundDaemon so the
+// launcher's upgrade path and `flo daemon stop` behave identically: graceful
+// signal → wait → liveness check → force kill. The prior implementation sent
+// bare `process.kill(pid, 'SIGTERM')` on every platform, which on Windows
+// either silently force-kills or fails entirely depending on the process; in
+// either case the catch swallowed the outcome and the lockfile was unlinked.
+// The daemon (if it survived) then re-wrote the lockfile with its stale PID +
+// pre-upgrade version, defeating the section-3a-pre version-skew recovery and
+// leaving the statusline stuck on `📊 ?` until manual `flo daemon restart`.
 //
 // Section 4's `hooks.mjs session-start` spawn is responsible for starting a
 // fresh daemon under the current code; this function intentionally does not.
@@ -372,11 +429,61 @@ function stopDaemon(lockFile) {
     const lock = JSON.parse(readFileSync(lockFile, 'utf-8'));
     if (typeof lock?.pid === 'number' && lock.pid > 0) stalePid = lock.pid;
   } catch { /* malformed lock — fall through to unlink */ }
-  if (stalePid !== null) {
-    try { process.kill(stalePid, 'SIGTERM'); } catch { /* already dead */ }
+
+  let killed = false;
+  if (stalePid !== null && isDaemonPidAlive(stalePid)) {
+    // Graceful signal — platform-aware. On Windows, `process.kill(pid, 'SIGTERM')`
+    // silently force-kills (skipping the daemon's shutdown handlers that flush
+    // sql.js + release lock cleanly), so use bare `taskkill` (no /F) for a
+    // close-event signal.
+    try {
+      if (process.platform === 'win32') {
+        execFileSync('taskkill', ['/PID', String(stalePid)], { windowsHide: true, timeout: 5000 });
+      } else {
+        process.kill(stalePid, 'SIGTERM');
+      }
+    } catch { /* signal/spawn failed — fall through to liveness poll + force */ }
+
+    // Poll for death up to 3s. The daemon's shutdown handler does a final
+    // sql.js dump + lock release, which under load can take ~1s.
+    const gracefulDeadline = Date.now() + 3000;
+    while (Date.now() < gracefulDeadline) {
+      if (!isDaemonPidAlive(stalePid)) { killed = true; break; }
+      sleepSyncMs(100);
+    }
+
+    // Force-kill if still alive.
+    if (!killed) {
+      try {
+        if (process.platform === 'win32') {
+          execFileSync('taskkill', ['/F', '/T', '/PID', String(stalePid)], { windowsHide: true, timeout: 5000 });
+        } else {
+          process.kill(stalePid, 'SIGKILL');
+        }
+      } catch { /* dead or unreachable */ }
+      // Short grace period for OS reap.
+      const forceDeadline = Date.now() + 1000;
+      while (Date.now() < forceDeadline) {
+        if (!isDaemonPidAlive(stalePid)) { killed = true; break; }
+        sleepSyncMs(100);
+      }
+    }
+
+    if (!killed) {
+      // Daemon survived both signals. Leave the lockfile in place so the next
+      // session can see the stale PID and retry — unlinking now would let the
+      // surviving daemon re-write the lockfile with its stale PID + version,
+      // perpetuating the loop this fix exists to break.
+      emitWarning(`stopDaemon: PID ${stalePid} did not exit after SIGTERM+force-kill; lockfile preserved`);
+      return false;
+    }
+  } else if (stalePid !== null) {
+    // PID was in the lockfile but the process is already gone — clean unlink.
+    killed = true;
   }
+
   try { unlinkSync(lockFile); } catch { /* non-fatal */ }
-  return stalePid !== null;
+  return killed;
 }
 
 // Stop-and-restart helper for the stale-daemon branch (section 3a-pre). The
@@ -720,7 +827,7 @@ try {
 
       // ── Sync .claude/agents/ + .claude/skills/ recursively (#948) ──────
       // Pre-#948, agents and skills weren't manifest-tracked at all, so any
-      // file moflo retired (e.g. the 49 ruflo-aspirational agents in #932 or
+      // file moflo retired (e.g. the 49 aspirational agents in #932 or
       // skill-builder in #945) would linger forever in consumer projects —
       // Claude Code kept loading them on every prompt, paying the per-prompt
       // roster tokens we just spent #932 fixing. Walking these dirs through

package/dist/src/cli/commands/doctor-checks-config.js

@@ -13,7 +13,7 @@ import { errorDetail } from '../shared/utils/error-detail.js';
 export async function checkConfigFile() {
     // JSON configs (parse-validated). LEGACY-CONFIG: `.claude-flow.json` and
     // `claude-flow.config.json` filenames are still recognised so consumers
-    // upgrading from pre-#699 moflo builds (upstream Ruflo) keep working
+    // upgrading from pre-#699 moflo builds keep working
     // without manual rename. Drift guard exempts these via LEGACY-CONFIG marker.
     const jsonPaths = [
         '.moflo/config.json',
@@ -233,18 +233,18 @@ export async function checkMcpServers() {
                 const content = JSON.parse(readFileSync(configPath, 'utf8'));
                 const servers = content.mcpServers || content.servers || {};
                 const count = Object.keys(servers).length;
-                const hasClaudeFlow = 'moflo' in servers || 'claude-flow' in servers || 'claude-flow_alpha' in servers || 'ruflo' in servers || 'ruflo_alpha' in servers;
+                const hasClaudeFlow = 'moflo' in servers || 'claude-flow' in servers || 'claude-flow_alpha' in servers;
                 if (hasClaudeFlow) {
                     return { name: 'MCP Servers', status: 'pass', message: `${count} servers (flo configured)` };
                 }
-                return { name: 'MCP Servers', status: 'warn', message: `${count} servers (flo not found)`, fix: 'claude mcp add ruflo -- npx -y ruflo@latest mcp start' };
+                return { name: 'MCP Servers', status: 'warn', message: `${count} servers (flo not found)`, fix: 'claude mcp add moflo -- npx -y moflo mcp start' };
             }
             catch {
                 // continue to next path
             }
         }
     }
-    return { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add moflo npx moflo mcp start' };
+    return { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add moflo -- npx -y moflo mcp start' };
 }
 // Catches three failure modes (#895):
 //   1. File missing — session-start should have created it; warn user that

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

@@ -27,7 +27,7 @@ function readCurrentVersion() {
                     const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
                     if (pkg.version &&
                         typeof pkg.name === 'string' &&
-                        (pkg.name === 'moflo' || pkg.name === 'claude-flow' || pkg.name === 'ruflo')) {
+                        (pkg.name === 'moflo' || pkg.name === 'claude-flow')) {
                         return pkg.version;
                     }
                 }

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

@@ -62,8 +62,6 @@ const commandLoaders = {
     benchmark: () => import('./benchmark.js'),
     // Guidance Control Plane
     guidance: () => import('./guidance.js'),
-    // RVFA Appliance Management
-    appliance: () => import('./appliance.js'),
     // MoFlo Spell Gates
     gate: () => import('./gate.js'),
     // Feature Orchestrator
@@ -137,7 +135,6 @@ import { issuesCommand } from './issues.js';
 import updateCommand from './update.js';
 import { processCommand } from './process.js';
 import { guidanceCommand } from './guidance.js';
-import { applianceCommand } from './appliance.js';
 import { diagnoseCommand } from './diagnose.js';
 import { githubCommand } from './github.js';
 // Pre-populate cache with core commands
@@ -184,7 +181,6 @@ export { performanceCommand } from './performance.js';
 export { securityCommand } from './security.js';
 export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
-export { applianceCommand } from './appliance.js';
 export { diagnoseCommand } from './diagnose.js';
 export { githubCommand } from './github.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
@@ -209,7 +205,6 @@ export async function getRouteCommand() { return loadCommand('route'); }
 export async function getProgressCommand() { return loadCommand('progress'); }
 export async function getIssuesCommand() { return loadCommand('issues'); }
 export async function getGuidanceCommand() { return loadCommand('guidance'); }
-export async function getApplianceCommand() { return loadCommand('appliance'); }
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup
@@ -285,7 +280,6 @@ export const commandsByCategory = {
         issuesCommand,
         updateCommand,
         processCommand,
-        applianceCommand,
         githubCommand,
     ],
 };

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

@@ -70,8 +70,8 @@ const COMMANDS_MAP = {};
  * Agents to copy based on configuration. Exported for integrity tests.
  *
  * Each value is a directory name under `.claude/agents/` that ships in the
- * moflo package. After #932 retired ~50 ruflo-aspirational agents, the set
- * is narrowed to actual development specialties Claude is likely to invoke.
+ * moflo package. After #932 retired ~50 aspirational agents, the set is
+ * narrowed to actual development specialties Claude is likely to invoke.
  */
 export const AGENTS_MAP = {
     core: ['core'],

package/dist/src/cli/mcp-tools/swarm-tools.js

@@ -12,7 +12,7 @@ import { getSwarmCoordinator, isSwarmCoordinatorInitialized, } from './swarm-coo
 import { scaleHandler, SCALE_STRATEGIES, TARGET_AGENTS_MIN, TARGET_AGENTS_MAX, } from './swarm-scale-handler.js';
 import { findProjectRoot } from '../services/project-root.js';
 import { MOFLO_DIR } from '../services/moflo-paths.js';
-// Inputs accepted by the MCP layer (covers Ruflo aliases). The coordinator's
+// Inputs accepted by the MCP layer (covers legacy aliases). The coordinator's
 // TopologyType is narrower: 'mesh' | 'hierarchical' | 'centralized' | 'hybrid'.
 const TOPOLOGY_MAP = {
     hierarchical: 'hierarchical',
@@ -23,9 +23,8 @@ const TOPOLOGY_MAP = {
     'hierarchical-mesh': 'hybrid',
     hybrid: 'hybrid',
 };
-// Ported from Ruflo v3/mcp/tools/swarm-tools.ts. `unanimous`/`weighted`/
-// `majority` are the user-facing aliases; the coordinator only speaks
-// `byzantine`/`raft`/`gossip`/`paxos`.
+// `unanimous`/`weighted`/`majority` are the user-facing aliases; the
+// coordinator only speaks `byzantine`/`raft`/`gossip`/`paxos`.
 const CONSENSUS_MAP = {
     unanimous: { algorithm: 'byzantine', threshold: 1.0 },
     byzantine: { algorithm: 'byzantine', threshold: 1.0 },

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

@@ -1,8 +1,8 @@
 /**
  * MoFlo runtime state directory constants.
  *
- * MoFlo owns its state under `.moflo/` at the project root. The upstream Ruflo
- * fork used `.claude-flow/`; both legacy locations are still recognized as
+ * MoFlo owns its state under `.moflo/` at the project root. Pre-#699 builds
+ * used `.claude-flow/`; both legacy locations are still recognized as
  * read-only sources for the version-bump-gated cherry-pick (#851) but are
  * never relocated or renamed automatically — leaving them in place gives
  * consumers a recovery source and avoids the failure modes that motivated
@@ -27,11 +27,12 @@ export const MEMORY_DB_FILE = 'moflo.db';
 /** HNSW persisted index sidecar. Lives next to the DB at `<root>/.moflo/hnsw.index`. */
 export const HNSW_INDEX_FILE = 'hnsw.index';
 /**
- * Legacy runtime directory inherited from upstream Ruflo. Only referenced from
- * migration code paths — production code should use {@link MOFLO_DIR}.
+ * Legacy `.claude-flow/` runtime directory used by pre-#699 moflo builds.
+ * Only referenced from migration code paths — production code should use
+ * {@link MOFLO_DIR}.
  */
 export const LEGACY_CLAUDE_FLOW_DIR = '.claude-flow';
-/** Legacy `.swarm/` directory used by Ruflo + pre-#727 moflo for the memory DB. */
+/** Legacy `.swarm/` directory used by pre-#727 moflo builds for the memory DB. */
 export const LEGACY_SWARM_DIR = '.swarm';
 /** Legacy memory DB filename — only ever inside `.swarm/`. Pre-#727. */
 export const LEGACY_MEMORY_DB_FILE = 'memory.db';

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

@@ -116,8 +116,8 @@ export function mofloResolve(specifier) {
 // ≈ 6 hops to the moflo root. 12 gives headroom for worktree/monorepo layouts.
 const MAX_WALK_DEPTH = 12;
 // Names a package.json may carry while still being "us" — covers the moflo
-// rename and the upstream forks we tolerate during version migration.
-const MOFLO_PACKAGE_NAMES = new Set(['moflo', 'claude-flow', 'ruflo']);
+// rename from the pre-collapse claude-flow workspace.
+const MOFLO_PACKAGE_NAMES = new Set(['moflo', 'claude-flow']);
 // Walk up from this file's dir, returning the first non-null `test(dir)` result.
 function walkUpFromSelf(test) {
     let dir = dirname(fileURLToPath(import.meta.url));

package/dist/src/cli/shared/core/config/loader.js

@@ -11,8 +11,8 @@ import { defaultSystemConfig, mergeWithDefaults } from './defaults.js';
 /**
  * Configuration file names to search for. Canonical names come first;
  * `claude-flow.*` names are kept as legacy fallback so consumers upgrading
- * from older moflo builds (which inherited the upstream Ruflo filenames)
- * keep loading their existing config without a manual rename.
+ * from pre-#699 moflo builds keep loading their existing config without a
+ * manual rename.
  */
 const CONFIG_FILE_NAMES = [
     'moflo.config.json',

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

package/package.json

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