moflo 4.9.12 → 4.9.14

package/bin/index-patterns.mjs

@@ -27,11 +27,11 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
 import { resolve, dirname, relative, basename, extname } from 'path';
 import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
 import { resolveMofloBin } from './lib/resolve-bin.mjs';
 import { mofloResolveURL } from './lib/moflo-resolve.mjs';
 import { memoryDbPath, MOFLO_DIR } from './lib/moflo-paths.mjs';
 import { applyIncrementalChunks, computeContentListHash } from './lib/incremental-write.mjs';
+import { createProcessManager } from './lib/process-manager.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -342,20 +342,23 @@ async function main() {
   // Save hash
   writeFileSync(HASH_CACHE_PATH, currentHash, 'utf-8');
 
-  // Trigger embedding generation in background
+  // Trigger embedding generation in background. Register with the shared
+  // ProcessManager (#886) so doctor's zombie scan allowlists it and the
+  // session-end / smoke-teardown drain reaps it. Stable label dedupes against
+  // the index-all chain's later `build-embeddings` step when both run within
+  // the same lock window.
   try {
     const embeddingScript = resolveMofloBin(
       projectRoot, 'flo-embeddings', 'build-embeddings.mjs', { includeDevFallback: true },
     );
     if (embeddingScript) {
-      const child = spawn('node', [embeddingScript, '--namespace', NAMESPACE], {
-        cwd: projectRoot,
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: true,
-      });
-      child.unref();
-      debug('Embedding generation started in background');
+      const pm = createProcessManager(projectRoot);
+      const result = pm.spawn('node', [embeddingScript, '--namespace', NAMESPACE], `build-embeddings-${NAMESPACE}`);
+      if (result.skipped) {
+        debug(`Embedding generation already running (PID: ${result.pid})`);
+      } else if (result.pid) {
+        debug(`Embedding generation started in background (PID: ${result.pid})`);
+      }
     }
   } catch { /* ignore */ }
 

package/bin/session-start-launcher.mjs

@@ -409,7 +409,7 @@ try {
         ];
         const cherryPickPath = cherryPickPaths.find((p) => existsSync(p));
         if (cherryPickPath) {
-          const mod = await import(`file://${cherryPickPath.replace(/\\/g, '/')}`);
+          const mod = await import(pathToFileURL(cherryPickPath).href);
           if (typeof mod.cherryPickLearningsFromLegacy === 'function') {
             const result = await mod.cherryPickLearningsFromLegacy({ projectRoot });
             if (result.copied > 0) {
@@ -595,7 +595,7 @@ try {
 
         // Gate and hook helpers — shipped as static files in bin/
         const binHelperFiles = [
-          'gate.cjs', 'gate-hook.mjs', 'prompt-hook.mjs', 'hook-handler.cjs',
+          'gate.cjs', 'gate-hook.mjs', 'prompt-hook.mjs', 'hook-handler.cjs', 'simplify-classify.cjs',
         ];
         for (const file of binHelperFiles) {
           await syncFile(resolve(binDir, file), resolve(helpersDir, file), `.claude/helpers/${file}`);
@@ -858,7 +858,7 @@ try {
       ];
       const hwPath = hwPaths.find(p => existsSync(p));
       if (hwPath) {
-        const mod = await import(`file://${hwPath.replace(/\\/g, '/')}`);
+        const mod = await import(pathToFileURL(hwPath).href);
         if (typeof mod.rewriteIncorrectHookWiring === 'function') {
           const { rewrites } = mod.rewriteIncorrectHookWiring(settings);
           if (rewrites.length > 0) {
@@ -958,8 +958,28 @@ async function runHookBlockDriftCheck() {
 
   if (report.drifted) {
     const wantRegenerate = autoUpdateConfig.hookBlockDrift === 'regenerate';
-    const safeToRegenerate = wantRegenerate && report.extra.length === 0;
-    if (safeToRegenerate && typeof mod.applyAdditiveRegeneration === 'function') {
+    // #896: regenerate is wholesale when available — the additive variant
+    // can't drop stale extras (e.g. the `gate.cjs session-reset` SessionStart
+    // hook removed in #842), which is the very case consumers hit. Older
+    // moflo installs without `applyWholesaleRegeneration` fall back to the
+    // additive path, which still heals purely-additive drift.
+    const wholesale = wantRegenerate && typeof mod.applyWholesaleRegeneration === 'function';
+    const additiveSafe = wantRegenerate && !wholesale &&
+      report.extra.length === 0 && typeof mod.applyAdditiveRegeneration === 'function';
+    if (wholesale) {
+      const { added, removed } = mod.applyWholesaleRegeneration(settings, report);
+      if (added > 0 || removed > 0) {
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        regenerated = true;
+        const parts = [];
+        if (added > 0) parts.push(`added ${plural(added, 'missing entry')}`);
+        if (removed > 0) parts.push(`removed ${plural(removed, 'stale entry')}`);
+        emitMutation(
+          'regenerated hook block',
+          `${parts.join(', ')} (drift ${report.consumerHash} → ${report.referenceHash})`,
+        );
+      }
+    } else if (additiveSafe) {
       const { added } = mod.applyAdditiveRegeneration(settings, report);
       if (added > 0) {
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
@@ -1102,6 +1122,40 @@ try {
   }
 } catch { /* non-fatal */ }
 
+// ── 3d-yaml-create. Create moflo.yaml if missing (#895) ────────────────────
+// Sibling self-heal to 3d-yaml: that block APPENDS new sections to existing
+// yaml; this block CREATES the file from the canonical template when no yaml
+// exists at all. Without it, consumers picking up new defaults via npm-install
+// (e.g. PR #894 flipped model_routing.enabled to true) have no surface to
+// see/tune them — the DEFAULT_CONFIG fallback is invisible.
+//
+// Runs BEFORE 3d-yaml so the appender has a file to work with on the same
+// session. Steady-state hot path: the existsSync check below short-circuits
+// before any module load, so consumers with an existing yaml pay one stat call.
+try {
+  if (!existsSync(resolve(projectRoot, 'moflo.yaml'))) {
+    const tplPaths = [
+      resolve(projectRoot, 'node_modules/moflo/dist/src/cli/init/moflo-yaml-template.js'),
+      resolve(projectRoot, 'dist/src/cli/init/moflo-yaml-template.js'),
+    ];
+    const tplPath = tplPaths.find((p) => existsSync(p));
+    if (tplPath) {
+      const { ensureMofloYamlExists } = await import(pathToFileURL(tplPath).href);
+      const result = ensureMofloYamlExists(projectRoot);
+      if (result?.created) {
+        emitMutation(
+          'created moflo.yaml',
+          'review defaults — model routing, sandbox, gates, hooks',
+        );
+      }
+    }
+  }
+} catch (err) {
+  // Non-fatal — DEFAULT_CONFIG fallback still gives correct behavior; user
+  // just loses the visible/tunable surface until next session retries (#854).
+  emitWarning(`moflo.yaml create skipped (${errMessage(err)})`);
+}
+
 // ── 3d-yaml. Append missing top-level sections to moflo.yaml ───────────────
 // Users must never be required to re-run `moflo init` after a version bump.
 // When moflo ships a new top-level config section (e.g. sandbox:), append it
@@ -1116,7 +1170,7 @@ try {
   const upgraderPath = upgraderPaths.find((p) => existsSync(p));
   const mofloYaml = resolve(projectRoot, 'moflo.yaml');
   if (upgraderPath && existsSync(mofloYaml)) {
-    const { ensureYamlSections } = await import(`file://${upgraderPath.replace(/\\/g, '/')}`);
+    const { ensureYamlSections } = await import(pathToFileURL(upgraderPath).href);
     const appended = ensureYamlSections(mofloYaml);
     if (Array.isArray(appended) && appended.length > 0) {
       emitMutation(
@@ -1135,7 +1189,7 @@ try {
   const localShimLib = resolve(projectRoot, 'bin/lib/install-global-shim.mjs');
   const shimPath = existsSync(shimLib) ? shimLib : existsSync(localShimLib) ? localShimLib : null;
   if (shimPath) {
-    const { installGlobalShim } = await import(`file://${shimPath.replace(/\\/g, '/')}`);
+    const { installGlobalShim } = await import(pathToFileURL(shimPath).href);
     const shimResult = installGlobalShim({ silent: true });
     if (shimResult?.installed) {
       emitMutation('installed global flo shim', 'bare `flo` now resolves to project install');
@@ -1162,7 +1216,7 @@ try {
   ];
   const migrationPath = migrationPaths.find((p) => existsSync(p));
   if (migrationPath) {
-    const mod = await import(`file://${migrationPath.replace(/\\/g, '/')}`);
+    const mod = await import(pathToFileURL(migrationPath).href);
     if (typeof mod.runEmbeddingsMigrationIfNeeded === 'function') {
       await mod.runEmbeddingsMigrationIfNeeded({
         out: process.stderr,
@@ -1198,7 +1252,7 @@ try {
   ];
   const purgePath = purgePaths.find((p) => existsSync(p));
   if (purgePath) {
-    const { purgeSoftDeletedEntries } = await import(`file://${purgePath.replace(/\\/g, '/')}`);
+    const { purgeSoftDeletedEntries } = await import(pathToFileURL(purgePath).href);
     const result = await purgeSoftDeletedEntries();
     if (result?.purged > 0) {
       emitMutation(
@@ -1230,7 +1284,7 @@ try {
   ];
   const purgePath = purgePaths.find((p) => existsSync(p));
   if (purgePath) {
-    const { purgeEphemeralNamespaces } = await import(`file://${purgePath.replace(/\\/g, '/')}`);
+    const { purgeEphemeralNamespaces } = await import(pathToFileURL(purgePath).href);
     const result = await purgeEphemeralNamespaces();
     if (result?.purged > 0) {
       emitMutation(

package/bin/simplify-classify.cjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+/**
+ * /simplify diff classifier — issue #908.
+ *
+ * Decides which review tier the current diff warrants and returns a JSON
+ * dispatch decision. The /simplify skill MUST call this first so routing is
+ * deterministic and unit-testable instead of a prose decision Claude makes
+ * over and over per run.
+ *
+ * Rule (per user direction): default to single-agent Sonnet review. Only
+ * escalate to a 3-agent fan-out when diff signals genuinely warrant it.
+ * Opus is never selected — the existing skill already documents that.
+ *
+ * Outputs JSON:
+ *   {
+ *     "tier": "TRIVIAL" | "SMALL" | "NORMAL",
+ *     "model": "sonnet",
+ *     "agentCount": 0 | 1 | 3,
+ *     "reasoning": [string, ...],
+ *     "stats": { added, deleted, fileCount, declAdded, declRemoved, ... }
+ *   }
+ *
+ * Usage:
+ *   node bin/simplify-classify.cjs [--base main]
+ *   node bin/simplify-classify.cjs --diff <unified-diff-on-stdin>
+ *
+ * The --diff stdin form exists so unit tests can drive the classifier
+ * with synthetic diffs (no git repo required).
+ */
+'use strict';
+
+const { execSync } = require('child_process');
+
+// Paths where new logic warrants the 3-agent fan-out (issue #908).
+// Mechanical edits inside these paths are still SMALL; only adding/removing
+// declarations triggers escalation.
+const SECURITY_PATHS = [
+  /(?:^|[\\\/])aidefence[\\\/]/i,
+  /(?:^|[\\\/])swarm[\\\/]consensus[\\\/]/i,
+  /(?:^|[\\\/])hooks?[\\\/](?:handlers?|gate|wiring)/i,
+  /(?:^|[\\\/])services[\\\/]daemon-lock\.ts$/i,
+  /(?:^|[\\\/])bin[\\\/]gate\./i,
+  /(?:^|[\\\/])bin[\\\/]session-start-launcher\./i,
+  /(?:^|[\\\/])\.claude[\\\/]helpers[\\\/]gate/i,
+];
+
+function safeExec(cmd) {
+  try { return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }); }
+  catch { return ''; }
+}
+
+function readDiffFromGit(base) {
+  // Combined diff: committed-since-base + working-tree
+  const committed = safeExec(`git diff ${base}...HEAD`);
+  const working = safeExec('git diff HEAD');
+  return committed + (working ? '\n' + working : '');
+}
+
+/**
+ * Parse a unified-diff string into per-file stats and aggregate signals.
+ * No git/I/O — pure function over the diff text. Test-friendly.
+ */
+function parseDiff(diff) {
+  const lines = diff.split('\n');
+  const files = new Map(); // filename → { added, deleted, declAdded, declRemoved, isNew, isRenamed }
+  let current = null;
+
+  // Match function/class/export-const-arrow/method declarations being
+  // added or removed. Conservative — biased toward false negatives so we
+  // don't over-escalate.
+  const DECL_RE = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|class|interface|type)\s+\w/;
+  const ARROW_DECL_RE = /^(?:export\s+)?(?:const|let|var)\s+\w+\s*[:=].*=>\s*\{?$/;
+
+  for (let i = 0; i < lines.length; i++) {
+    const ln = lines[i];
+
+    // File header: `diff --git a/path b/path`
+    let m = ln.match(/^diff --git (?:a\/)?(.+?) (?:b\/)?(.+)$/);
+    if (m) {
+      const filename = m[2];
+      current = { filename, added: 0, deleted: 0, declAdded: 0, declRemoved: 0, isNew: false, isRenamed: false };
+      files.set(filename, current);
+      continue;
+    }
+    if (!current) continue;
+
+    if (ln.startsWith('new file mode')) current.isNew = true;
+    if (ln.startsWith('rename from') || ln.startsWith('rename to') || ln.startsWith('similarity index')) current.isRenamed = true;
+
+    // Skip diff headers
+    if (ln.startsWith('+++') || ln.startsWith('---') || ln.startsWith('@@') || ln.startsWith('index ')) continue;
+
+    if (ln.startsWith('+') && !ln.startsWith('+++')) {
+      current.added++;
+      const body = ln.slice(1).trim();
+      if (DECL_RE.test(body) || ARROW_DECL_RE.test(body)) current.declAdded++;
+    } else if (ln.startsWith('-') && !ln.startsWith('---')) {
+      current.deleted++;
+      const body = ln.slice(1).trim();
+      if (DECL_RE.test(body) || ARROW_DECL_RE.test(body)) current.declRemoved++;
+    }
+  }
+
+  // Aggregate
+  let added = 0, deleted = 0, declAdded = 0, declRemoved = 0;
+  let newFiles = 0, renamedFiles = 0;
+  let securityHit = false;
+  for (const f of files.values()) {
+    added += f.added;
+    deleted += f.deleted;
+    declAdded += f.declAdded;
+    declRemoved += f.declRemoved;
+    if (f.isNew) newFiles++;
+    if (f.isRenamed) renamedFiles++;
+    if (SECURITY_PATHS.some(rx => rx.test(f.filename))) securityHit = true;
+  }
+
+  return {
+    added, deleted, declAdded, declRemoved,
+    netDecls: declAdded - declRemoved,
+    fileCount: files.size,
+    newFiles, renamedFiles,
+    securityHit,
+    files: [...files.keys()],
+  };
+}
+
+/**
+ * Pure decision function. Takes parsed stats, returns dispatch decision.
+ * No I/O. Easy to unit-test with synthetic stats.
+ */
+function decide(stats) {
+  const reasoning = [];
+  const totalChange = stats.added + stats.deleted;
+
+  if (totalChange === 0) {
+    return { tier: 'TRIVIAL', model: 'sonnet', agentCount: 0, reasoning: ['empty diff — nothing to review'], stats };
+  }
+
+  // TRIVIAL: tiny diff, no declarations changed
+  if (totalChange <= 10 && stats.fileCount <= 1 && stats.netDecls === 0 && stats.declAdded === 0 && stats.declRemoved === 0) {
+    reasoning.push(`≤10 LOC in 1 file with no declaration changes`);
+    return { tier: 'TRIVIAL', model: 'sonnet', agentCount: 0, reasoning, stats };
+  }
+
+  // Mechanical relocation detection — the #906 case.
+  // If declarations were both ADDED and REMOVED at roughly matching rates,
+  // it's a structural move, not net-new logic. Judge by declaration balance,
+  // not raw LOC balance — formatting/blank-line differences between source
+  // and destination files easily push raw LOC out of balance even when the
+  // semantic change is purely "moved 5 functions across 5 new files".
+  // Mechanical relocations are SMALL even when many files / many lines.
+  const declTouched = stats.declAdded + stats.declRemoved;
+  const isMostlyRelocation = stats.declAdded >= 2
+    && stats.declRemoved >= 2
+    && Math.abs(stats.netDecls) <= Math.max(2, Math.floor(declTouched * 0.30));
+
+  if (isMostlyRelocation) {
+    reasoning.push(
+      `mostly relocation: ${stats.declAdded} decls added, ${stats.declRemoved} removed, net ${stats.netDecls >= 0 ? '+' : ''}${stats.netDecls}`,
+    );
+    return { tier: 'SMALL', model: 'sonnet', agentCount: 1, reasoning, stats };
+  }
+
+  // Escalation triggers — any one trips NORMAL (3 agents).
+  // Always Sonnet — Opus is never the right model for /simplify per skill rule.
+  const triggers = [];
+  if (totalChange > 500) triggers.push(`>500 LOC changed (${totalChange})`);
+  if (stats.fileCount >= 5 && stats.netDecls >= 3) triggers.push(`${stats.fileCount} files with ${stats.netDecls} net new declarations`);
+  if (stats.securityHit && stats.netDecls > 0) triggers.push('security-sensitive path with new logic');
+  if (stats.newFiles >= 3 && stats.declAdded >= 5) triggers.push(`${stats.newFiles} new files with ${stats.declAdded} new declarations`);
+
+  if (triggers.length > 0) {
+    return { tier: 'NORMAL', model: 'sonnet', agentCount: 3, reasoning: triggers, stats };
+  }
+
+  // Default: SMALL — single sonnet agent
+  reasoning.push(`small/medium diff: ${totalChange} LOC across ${stats.fileCount} file(s), +${stats.declAdded}/-${stats.declRemoved} decls`);
+  return { tier: 'SMALL', model: 'sonnet', agentCount: 1, reasoning, stats };
+}
+
+function classifyDiff(diffText) {
+  return decide(parseDiff(diffText));
+}
+
+function classifyFromGit(base = 'main') {
+  return classifyDiff(readDiffFromGit(base));
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const baseIdx = args.indexOf('--base');
+  const base = baseIdx >= 0 ? args[baseIdx + 1] : 'main';
+  const stdinDiff = args.includes('--diff') || args.includes('--stdin');
+
+  let result;
+  if (stdinDiff) {
+    let buf = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (d) => { buf += d; });
+    process.stdin.on('end', () => {
+      result = classifyDiff(buf);
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    });
+  } else {
+    result = classifyFromGit(base);
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  }
+}
+
+module.exports = { parseDiff, decide, classifyDiff, classifyFromGit };

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

@@ -0,0 +1,246 @@
+/**
+ * Configuration & service-discovery checks for `flo doctor`:
+ * config files, statusLine, daemon, MCP servers, moflo.yaml compliance,
+ * test directories.
+ */
+import { existsSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+import { getDaemonLockHolder } from '../services/daemon-lock.js';
+import { legacyMemoryDbPath, memoryDbCandidatePaths, memoryDbPath, } from '../services/moflo-paths.js';
+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
+    // without manual rename. Drift guard exempts these via LEGACY-CONFIG marker.
+    const jsonPaths = [
+        '.moflo/config.json',
+        'moflo.config.json',
+        'claude-flow.config.json', // LEGACY-CONFIG: pre-#699 fallback
+        '.claude-flow.json', // LEGACY-CONFIG: pre-#699 fallback
+    ];
+    for (const configPath of jsonPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf8');
+                JSON.parse(content);
+                return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
+            }
+            catch {
+                return { name: 'Config File', status: 'fail', message: `Invalid JSON: ${configPath}`, fix: 'Fix JSON syntax in config file' };
+            }
+        }
+    }
+    // YAML configs (existence-checked only — no heavy yaml parser dependency).
+    const yamlPaths = [
+        '.moflo/config.yaml',
+        '.moflo/config.yml',
+        'moflo.config.yaml',
+        'claude-flow.config.yaml', // LEGACY-CONFIG: pre-#699 fallback
+    ];
+    for (const configPath of yamlPaths) {
+        if (existsSync(configPath)) {
+            return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
+        }
+    }
+    return { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'claude-flow config init' };
+}
+export async function checkStatusLine() {
+    const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+    if (!existsSync(settingsPath)) {
+        return { name: 'Status Line', status: 'warn', message: 'No .claude/settings.json found', fix: 'npx moflo init' };
+    }
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        if (settings.statusLine && settings.statusLine.command) {
+            if (settings.statusLine.command.includes('statusline.cjs')) {
+                return { name: 'Status Line', status: 'pass', message: 'Wired in settings.json' };
+            }
+            return { name: 'Status Line', status: 'pass', message: 'Custom statusLine configured' };
+        }
+        return { name: 'Status Line', status: 'fail', message: 'statusLine not configured in settings.json', fix: 'Add statusLine config to .claude/settings.json' };
+    }
+    catch {
+        return { name: 'Status Line', status: 'fail', message: 'Failed to parse .claude/settings.json', fix: 'Fix JSON syntax in .claude/settings.json' };
+    }
+}
+// Delegates to daemon-lock module for proper PID + command-line verification
+// (avoids Windows PID-recycling false positives).
+export async function checkDaemonStatus() {
+    try {
+        // Retry up to 5 times with 1s delay — the daemon starts in the background
+        // during session-start and may not have acquired its lock file yet.
+        const MAX_RETRIES = 5;
+        const RETRY_DELAY_MS = 1000;
+        let holderPid = null;
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            holderPid = getDaemonLockHolder(process.cwd());
+            if (holderPid)
+                break;
+            if (attempt < MAX_RETRIES - 1) {
+                await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+            }
+        }
+        if (holderPid) {
+            return { name: 'Daemon Status', status: 'pass', message: `Running (PID: ${holderPid})` };
+        }
+        // getDaemonLockHolder auto-cleans stale locks, but check for legacy PID file
+        const lockFile = '.moflo/daemon.lock';
+        if (existsSync(lockFile)) {
+            return { name: 'Daemon Status', status: 'warn', message: 'Stale lock file', fix: 'rm .moflo/daemon.lock && claude-flow daemon start' };
+        }
+        const pidFile = '.moflo/daemon.pid';
+        if (existsSync(pidFile)) {
+            return { name: 'Daemon Status', status: 'warn', message: 'Legacy PID file found', fix: 'rm .moflo/daemon.pid && claude-flow daemon start' };
+        }
+        return { name: 'Daemon Status', status: 'warn', message: 'Not running', fix: 'claude-flow daemon start' };
+    }
+    catch (e) {
+        return { name: 'Daemon Status', status: 'warn', message: `Unable to check: ${errorDetail(e)}`, fix: 'claude-flow daemon status' };
+    }
+}
+export async function checkMemoryDatabase() {
+    const root = process.cwd();
+    const canonical = memoryDbPath(root);
+    for (const dbPath of memoryDbCandidatePaths(root)) {
+        let stats;
+        try {
+            stats = statSync(dbPath);
+        }
+        catch {
+            continue;
+        }
+        const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+        if (dbPath === canonical) {
+            let message = `.moflo/moflo.db (${sizeMB} MB)`;
+            // Unfinished migration tail: source still present means the launcher's
+            // rename-to-.bak step failed (Windows lock most often). Flag so the user
+            // knows to clear the stale source.
+            if (existsSync(legacyMemoryDbPath(root))) {
+                message += ' — legacy .swarm/memory.db still present (delete it after confirming canonical is healthy)';
+            }
+            return { name: 'Memory Database', status: 'pass', message };
+        }
+        return {
+            name: 'Memory Database',
+            status: 'warn',
+            message: `${dbPath} (${sizeMB} MB) — legacy location, will migrate to .moflo/moflo.db on next session start`,
+            fix: 'restart claude code session',
+        };
+    }
+    return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
+}
+export async function checkMcpServers() {
+    const mcpConfigPaths = [
+        join(os.homedir(), '.claude/claude_desktop_config.json'),
+        join(os.homedir(), '.config/claude/mcp.json'),
+        '.mcp.json',
+        // Windows: Claude Desktop stores config under %APPDATA%\Claude\
+        ...(process.platform === 'win32' && process.env.APPDATA
+            ? [join(process.env.APPDATA, 'Claude', 'claude_desktop_config.json')]
+            : []),
+    ];
+    for (const configPath of mcpConfigPaths) {
+        if (existsSync(configPath)) {
+            try {
+                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;
+                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' };
+            }
+            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' };
+}
+// Catches three failure modes (#895):
+//   1. File missing — session-start should have created it; warn user that
+//      defaults are invisible/untunable.
+//   2. File empty / unreadable — corrupted by half-write or filesystem error.
+//   3. Top-level sections missing — partial yaml from manual edit or stale
+//      copy from a moflo version that didn't ship a section yet.
+//
+// Exported so tests can exercise it end-to-end against a temp project root
+// without mutating process.cwd() (which fights vitest's parallel test runner).
+export async function checkMofloYamlCompliance(cwd = process.cwd()) {
+    const yamlPath = join(cwd, 'moflo.yaml');
+    // Lazy-import the validator so doctor doesn't pull in fs walks on the
+    // happy path of unrelated checks.
+    const { validateMofloYaml } = await import('../init/moflo-yaml-template.js');
+    const result = validateMofloYaml(yamlPath);
+    if (!result.exists) {
+        return {
+            name: 'moflo.yaml',
+            status: 'warn',
+            message: 'moflo.yaml not found — defaults are in effect but not visible/tunable',
+            fix: 'Restart Claude Code (session-start auto-creates) or run `npx moflo init`',
+        };
+    }
+    if (result.valid) {
+        return { name: 'moflo.yaml', status: 'pass', message: `Compliant (${yamlPath})` };
+    }
+    const parseIssue = result.issues.find((i) => i.kind !== 'missing-section');
+    if (parseIssue) {
+        return {
+            name: 'moflo.yaml',
+            status: 'fail',
+            message: `${parseIssue.kind}: ${parseIssue.detail}`,
+            fix: 'Inspect/repair moflo.yaml, or `mv moflo.yaml moflo.yaml.bak && npx moflo init`',
+        };
+    }
+    return {
+        name: 'moflo.yaml',
+        status: 'warn',
+        message: `Missing sections: ${result.missingSections.join(', ')}`,
+        fix: 'Restart Claude Code (yaml-upgrader auto-appends) or `npx moflo init --force`',
+    };
+}
+export async function checkTestDirs() {
+    const yamlPath = join(process.cwd(), 'moflo.yaml');
+    if (!existsSync(yamlPath)) {
+        return { name: 'Test Directories', status: 'warn', message: 'No moflo.yaml — test indexing unconfigured', fix: 'npx moflo init' };
+    }
+    try {
+        const content = readFileSync(yamlPath, 'utf-8');
+        const testsBlock = content.match(/tests:\s*\n\s+directories:\s*\n((?:\s+-\s+.+\n?)+)/);
+        if (!testsBlock) {
+            return { name: 'Test Directories', status: 'warn', message: 'No tests section in moflo.yaml', fix: 'npx moflo init --force' };
+        }
+        const items = testsBlock[1].match(/-\s+(.+)/g);
+        if (!items || items.length === 0) {
+            return { name: 'Test Directories', status: 'warn', message: 'Empty test directories list' };
+        }
+        const dirs = items.map(item => item.replace(/^-\s+/, '').trim());
+        const existing = dirs.filter(d => existsSync(join(process.cwd(), d)));
+        const missing = dirs.filter(d => !existsSync(join(process.cwd(), d)));
+        const autoIndexMatch = content.match(/auto_index:\s*\n(?:.*\n)*?\s+tests:\s*(true|false)/);
+        const autoIndexEnabled = !autoIndexMatch || autoIndexMatch[1] !== 'false';
+        const indexLabel = autoIndexEnabled ? 'auto-index: on' : 'auto-index: off';
+        if (missing.length > 0 && existing.length === 0) {
+            return {
+                name: 'Test Directories',
+                status: 'warn',
+                message: `No configured test dirs exist: ${missing.join(', ')} (${indexLabel})`,
+            };
+        }
+        if (missing.length > 0) {
+            return {
+                name: 'Test Directories',
+                status: 'warn',
+                message: `${existing.length} OK, ${missing.length} missing: ${missing.join(', ')} (${indexLabel})`,
+            };
+        }
+        return { name: 'Test Directories', status: 'pass', message: `${existing.length} directories: ${existing.join(', ')} (${indexLabel})` };
+    }
+    catch (e) {
+        return { name: 'Test Directories', status: 'warn', message: `Unable to parse moflo.yaml: ${errorDetail(e)}` };
+    }
+}
+//# sourceMappingURL=doctor-checks-config.js.map

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

@@ -593,6 +593,20 @@ export async function checkHookBlockDrift() {
             message: 'drift check skipped — claudeFlow.hooks.locked: true',
         };
     }
+    // #896: respect `auto_update.hook_block_drift: off` — opt-out for consumers
+    // who explicitly don't want drift surfaced (mirrors the launcher's behaviour).
+    try {
+        const { loadMofloConfig } = await import('../config/moflo-config.js');
+        const cfg = loadMofloConfig(projectDir);
+        if (cfg.auto_update.hook_block_drift === 'off') {
+            return {
+                name: 'Hook Block Drift',
+                status: 'pass',
+                message: 'drift check skipped — auto_update.hook_block_drift: off',
+            };
+        }
+    }
+    catch { /* config read failure — fall through to drift check */ }
     const report = computeHookBlockDrift(settings.hooks ?? {});
     if (!report.drifted) {
         return {