moflo 4.10.1 → 4.10.3

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

@@ -12,7 +12,7 @@
  */
 import { output } from '../output.js';
 import { allChecks, componentMap, zombieScanCheck } from './doctor-registry.js';
-import { emitJsonOutput, finalize, formatCheck, maybeAutoInstallClaudeCode, renderSummary, runAutoFix, runKillZombiesBanner, } from './doctor-render.js';
+import { emitJsonOutput, finalize, formatCheck, maybeAutoInstallClaudeCode, renderSummary, runAutoFix, runKillZombies, } from './doctor-render.js';
 import { checkEmbeddings } from './doctor-checks-memory.js';
 import { checkMofloYamlCompliance } from './doctor-checks-config.js';
 // Re-export for tests + external consumers (#639 stale-vector-stats test
@@ -125,24 +125,21 @@ export const doctorCommand = {
             output.writeln(output.warning('--allow-warn requires --strict; ignoring (warnings are tolerated by default).'));
             output.writeln();
         }
-        if (killZombies) {
-            await runKillZombiesBanner();
-        }
         const checksToRun = component && componentMap[component]
             ? [componentMap[component]]
             : allChecks;
         const results = [];
         const fixes = [];
-        // OPTIMIZATION: Run all checks in parallel for 3-5x faster execution
-        const spinner = jsonOutput
-            ? null
-            : output.createSpinner({ text: 'Running health checks in parallel...', spinner: 'dots' });
-        spinner?.start();
+        let zombieScan;
+        let claudeCodeInstall;
+        let fixesApplied;
         // Issue #818: in --json mode, several deep checks (spell engine probe,
         // mcp-spell bridge, etc.) write `[spell] ...` log lines straight to
         // stdout — that breaks the single-JSON-document contract. Capture and
-        // discard stdout writes while checks run; restore in `finally` so a
-        // throw can't leave the process with a stubbed stdout.
+        // discard stdout writes while checks AND post-check actions run; restore
+        // in `finally` so a throw can't leave the process with a stubbed stdout.
+        // Issue #1122: extended to wrap zombie-kill banner, --install, and
+        // --fix work so each runs on the JSON path with prose suppressed.
         const realStdoutWrite = process.stdout.write.bind(process.stdout);
         const restoreStdout = () => {
             if (jsonOutput) {
@@ -153,7 +150,18 @@ export const doctorCommand = {
             process.stdout.write =
                 (..._args) => true;
         }
+        // OPTIMIZATION: Run all checks in parallel for 3-5x faster execution
+        const spinner = jsonOutput
+            ? null
+            : output.createSpinner({ text: 'Running health checks in parallel...', spinner: 'dots' });
         try {
+            // Issue #1122: kill-zombies prose used to write BEFORE the JSON
+            // suppression activated, corrupting the JSON document. Now runs
+            // under suppression and feeds a structured result into the payload.
+            if (killZombies) {
+                zombieScan = await runKillZombies({ silent: jsonOutput });
+            }
+            spinner?.start();
             let checkResults;
             try {
                 checkResults = await Promise.allSettled(checksToRun.map(check => check()));
@@ -174,7 +182,6 @@ export const doctorCommand = {
             }
             finally {
                 spinner?.stop();
-                restoreStdout();
             }
             for (const settledResult of checkResults) {
                 if (settledResult.status === 'fulfilled') {
@@ -197,26 +204,64 @@ export const doctorCommand = {
                         output.writeln(formatCheck(errorResult));
                 }
             }
+            // Issue #1122: action flags must run on BOTH the JSON path and the
+            // formatted path. Previously the JSON branch early-returned before
+            // any of this ran, so `--json --fix` (and `--json --install`) silently
+            // no-op'd. Now they execute under stdout suppression and their
+            // outcomes feed the JSON payload below.
+            if (autoInstall) {
+                claudeCodeInstall = await maybeAutoInstallClaudeCode(results, fixes, { silent: jsonOutput });
+            }
+            if (!jsonOutput)
+                renderSummary(results);
+            if (showFix && fixes.length > 0) {
+                const outcome = await runAutoFix(results, fixes, checksToRun, { silent: jsonOutput });
+                fixesApplied = outcome.fixesApplied;
+                // Replace `results` with post-fix state so JSON consumers see the
+                // re-evaluated truth, not the pre-fix snapshot. Mirror the #992
+                // post-parallel zombie-scan append so the post-fix shape matches
+                // pre-fix shape (otherwise `--json --fix` silently drops the
+                // Zombie Processes entry from the JSON `results[]`).
+                if (outcome.reEvaluated) {
+                    const finalChecks = [...outcome.reEvaluated];
+                    if (!component) {
+                        try {
+                            finalChecks.push(await zombieScanCheck());
+                        }
+                        catch (reason) {
+                            finalChecks.push({
+                                name: 'Zombie Processes',
+                                status: 'fail',
+                                message: reason?.message ?? 'Unknown error',
+                            });
+                        }
+                    }
+                    results.length = 0;
+                    results.push(...finalChecks);
+                }
+            }
+            else if (fixes.length > 0 && !showFix && !jsonOutput) {
+                output.writeln();
+                output.writeln(output.dim(`Run with --fix to auto-fix ${fixes.length} issue${fixes.length > 1 ? 's' : ''}`));
+            }
         }
         catch {
             spinner?.stop();
-            restoreStdout();
             if (!jsonOutput)
                 output.writeln(output.error('Failed to run health checks'));
         }
-        if (jsonOutput) {
-            return emitJsonOutput({ results, strict, allowWarnList });
-        }
-        if (autoInstall) {
-            await maybeAutoInstallClaudeCode(results, fixes);
-        }
-        renderSummary(results);
-        if (showFix && fixes.length > 0) {
-            await runAutoFix(results, fixes, checksToRun);
+        finally {
+            restoreStdout();
         }
-        else if (fixes.length > 0 && !showFix) {
-            output.writeln();
-            output.writeln(output.dim(`Run with --fix to auto-fix ${fixes.length} issue${fixes.length > 1 ? 's' : ''}`));
+        if (jsonOutput) {
+            return emitJsonOutput({
+                results,
+                strict,
+                allowWarnList,
+                fixesApplied,
+                zombieScan,
+                claudeCodeInstall,
+            });
         }
         return finalize({ results, strict, allowWarnList });
     },

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/memory/bridge-core.js

@@ -95,6 +95,27 @@ export function logBridgeError(context, err, opts) {
     const msg = errorDetail(err);
     console.error(`[moflo] ${context}: ${msg}`);
 }
+/**
+ * Recognises the node:sqlite "operation on closed handle" error shape.
+ *
+ * #1123 — A concurrent `withDb` call's `checkBridgeCoherence` can fire
+ * `shutdownBridge()` between our `getDb(registry)` and `fn(ctx, registry)`,
+ * closing the underlying `DatabaseSync`. Our previously-captured `ctx.db`
+ * then throws `ERR_INVALID_STATE: database is not open` on the next op.
+ *
+ * The operation hadn't started its mutation yet, so a single retry against a
+ * fresh registry is safe (matches the `withBusyRetry` shape for SQLITE_BUSY).
+ * Bounded to one retry so a *genuinely* broken DB still surfaces — we don't
+ * want to mask a registry that can't be re-acquired.
+ */
+function isStaleHandleError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    if (e.code === 'ERR_INVALID_STATE')
+        return true;
+    return typeof e.message === 'string' && /database is not open/i.test(e.message);
+}
 /**
  * Treats an error as a SQLITE_BUSY lock-contention failure if either the
  * error code or message indicates it. Belt-and-suspenders around node:sqlite,
@@ -456,6 +477,9 @@ async function checkBridgeCoherence(dbPath) {
  * self-fire is suppressed.
  */
 export async function withDb(dbPath, fn) {
+    return withDbInner(dbPath, fn, 0);
+}
+async function withDbInner(dbPath, fn, attempt) {
     await checkBridgeCoherence(dbPath);
     const registry = await getRegistry(dbPath);
     if (!registry)
@@ -510,6 +534,18 @@ export async function withDb(dbPath, fn) {
         return result;
     }
     catch (err) {
+        // #1123 — stale-handle race: a concurrent withDb's coherence check tore
+        // the registry down between our getDb() and fn() execution, closing the
+        // underlying DatabaseSync. Drop the dead handle and retry once against a
+        // freshly-acquired registry. The first attempt threw BEFORE its mutation
+        // landed (node:sqlite errors at prepare/exec time, not mid-statement), so
+        // a retry is idempotent. Bounded to one retry so a genuinely-unrecoverable
+        // bridge (e.g. corrupt file, missing module) still surfaces as a null
+        // return + logged error, not an infinite loop.
+        if (attempt === 0 && isStaleHandleError(err)) {
+            await shutdownBridge();
+            return await withDbInner(dbPath, fn, attempt + 1);
+        }
         logBridgeError('bridge operation failed', err);
         return null;
     }

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

package/package.json

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