moflo 4.9.13 → 4.9.14

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-intelligence.js

@@ -0,0 +1,197 @@
+/**
+ * Intelligence-layer functional checks for `flo doctor`:
+ * SONA, ReasoningBank, PatternLearner, MicroLoRA + EWC++, RL algorithms.
+ *
+ * Each component is exercised with a lightweight functional test rather than
+ * just checking "loaded".
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+// Memory-backed pattern fallback (populated by pretrain) when an in-process
+// neural component returns no data. Uses the pattern-search handler that
+// pretrain writes to.
+async function checkMemoryPatterns(_namespace) {
+    try {
+        const hooksMod = await import('../mcp-tools/hooks-tools.js');
+        if (hooksMod.hooksPatternSearch) {
+            const result = await hooksMod.hooksPatternSearch.handler({
+                query: 'pretrain',
+                topK: 1,
+                minConfidence: 0.1,
+            });
+            const matches = result?.results;
+            if (Array.isArray(matches))
+                return matches.length;
+        }
+    }
+    catch {
+        // hooks module not available
+    }
+    // Secondary fallback: check the memory DB file exists
+    const dbPath = join(process.cwd(), '.claude', 'memory.db');
+    if (existsSync(dbPath))
+        return 1;
+    return 0;
+}
+export async function checkIntelligence() {
+    try {
+        const neural = await import('../neural/index.js');
+        const results = [];
+        const failures = [];
+        // 1. SONA — create manager, run trajectory lifecycle
+        try {
+            const sona = neural.createSONAManager('balanced');
+            await sona.initialize();
+            const tid = sona.beginTrajectory('doctor-check', 'general');
+            const embedding = new Float32Array(64).fill(0.1);
+            sona.recordStep(tid, 'test-action', 0.8, embedding);
+            const traj = sona.completeTrajectory(tid, 0.9);
+            if (traj && traj.steps.length > 0) {
+                results.push('SONA');
+            }
+            else {
+                failures.push('SONA (no trajectory output)');
+            }
+            await sona.cleanup();
+        }
+        catch (e) {
+            failures.push(`SONA (${e instanceof Error ? e.message : 'error'})`);
+        }
+        // 2. ReasoningBank — verify instantiation and trajectory store/distill lifecycle
+        try {
+            const rb = neural.createReasoningBank();
+            const stateAfter = new Float32Array(64).fill(0.2);
+            const trajectory = {
+                trajectoryId: 'doctor-test',
+                context: 'health check',
+                domain: 'general',
+                steps: [{ stepId: 's1', action: 'test', reward: 1, stateBefore: stateAfter, stateAfter, timestamp: Date.now() }],
+                startTime: Date.now(),
+                endTime: Date.now(),
+                qualityScore: 0.9,
+                isComplete: true,
+                verdict: {
+                    success: true,
+                    confidence: 0.9,
+                    strengths: ['health check passed'],
+                    weaknesses: [],
+                    improvements: [],
+                    relevanceScore: 0.9,
+                },
+            };
+            rb.storeTrajectory(trajectory);
+            // distill() populates memories (storeTrajectory alone does not)
+            const distilled = await rb.distill(trajectory);
+            if (distilled || rb.getTrajectories().length > 0) {
+                results.push('ReasoningBank');
+            }
+            else {
+                const memoryPatterns = await checkMemoryPatterns('patterns');
+                if (memoryPatterns > 0) {
+                    results.push('ReasoningBank(memory)');
+                }
+                else {
+                    failures.push('ReasoningBank (distill returned no data)');
+                }
+            }
+        }
+        catch (e) {
+            failures.push(`ReasoningBank (${e instanceof Error ? e.message : 'error'})`);
+        }
+        // 3. PatternLearner — extract + match
+        try {
+            const pl = neural.createPatternLearner();
+            const embedding = new Float32Array(64).fill(0.3);
+            const now = Date.now();
+            pl.extractPattern({
+                trajectoryId: 'doctor-pl', context: 'test', domain: 'general',
+                steps: [{ stepId: 's1', action: 'test', reward: 1, stateBefore: embedding, stateAfter: embedding, timestamp: now }],
+                startTime: now, endTime: now, qualityScore: 1, isComplete: true,
+            }, { memoryId: 'doctor-pl-mem', trajectoryId: 'doctor-pl', strategy: 'health-check', keyLearnings: ['test'], embedding, quality: 1, usageCount: 0, lastUsed: now });
+            const matches = pl.findMatches(embedding, 1);
+            if (matches.length > 0) {
+                results.push('PatternLearner');
+            }
+            else {
+                const memoryPatterns = await checkMemoryPatterns('patterns');
+                if (memoryPatterns > 0) {
+                    results.push('PatternLearner(memory)');
+                }
+                else {
+                    failures.push('PatternLearner (no matches)');
+                }
+            }
+        }
+        catch (e) {
+            failures.push(`PatternLearner (${e instanceof Error ? e.message : 'error'})`);
+        }
+        // 4. SONALearningEngine (MicroLoRA + EWC++)
+        try {
+            const engine = neural.createSONALearningEngine();
+            const ctx = { domain: 'general', queryEmbedding: new Float32Array(768).fill(0.1) };
+            const adapted = await engine.adapt(ctx);
+            const components = [];
+            if (adapted && adapted.transformedQuery)
+                components.push('LoRA');
+            if (adapted && adapted.patterns !== undefined)
+                components.push('EWC++');
+            if (components.length > 0) {
+                results.push(...components);
+            }
+            else {
+                failures.push('LoRA/EWC++ (adapt returned no data)');
+            }
+        }
+        catch (e) {
+            // Gracefully handle cold/uninitialized state
+            const msg = e instanceof Error ? e.message : 'error';
+            if (msg.includes('undefined') || msg.includes('not initialized')) {
+                results.push('LoRA/EWC++(cold)');
+            }
+            else {
+                failures.push(`LoRA/EWC++ (${msg})`);
+            }
+        }
+        // 5. RL Algorithms — quick instantiation check
+        try {
+            const algNames = [];
+            const ppo = neural.createPPO();
+            if (ppo)
+                algNames.push('PPO');
+            const dqn = neural.createDQN();
+            if (dqn)
+                algNames.push('DQN');
+            const ql = neural.createQLearning();
+            if (ql)
+                algNames.push('Q-Learn');
+            if (algNames.length > 0) {
+                results.push(`RL(${algNames.join('+')})`);
+            }
+        }
+        catch (e) {
+            failures.push(`RL (${e instanceof Error ? e.message : 'error'})`);
+        }
+        if (failures.length > 0) {
+            return {
+                name: 'Intelligence',
+                status: results.length > 0 ? 'warn' : 'fail',
+                message: `${results.join(', ')} OK; FAILED: ${failures.join(', ')}`,
+                fix: 'Check neural module imports and dependencies',
+            };
+        }
+        return {
+            name: 'Intelligence',
+            status: 'pass',
+            message: results.join(', '),
+        };
+    }
+    catch (e) {
+        return {
+            name: 'Intelligence',
+            status: 'warn',
+            message: `Module unavailable: ${e instanceof Error ? e.message.split(/\r?\n/)[0] : 'import failed'}`,
+            fix: 'Ensure moflo is built (npm run build)',
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-intelligence.js.map

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

@@ -0,0 +1,207 @@
+/**
+ * Memory + embeddings + semantic-search checks for `flo doctor`.
+ *
+ * `checkEmbeddings` is exported for the #639 stale-cache regression test
+ * (src/cli/__tests__/commands/doctor-stale-vector-stats.test.ts).
+ */
+import { existsSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+/** Skew (cached / live count delta) above which the cache is treated as stale. */
+const VECTOR_STATS_SKEW_WARN_THRESHOLD = 0.2;
+/**
+ * Open `dbPath` via moflo's bundled sql.js and return the count of memory_entries
+ * rows that have an embedding. Returns null if sql.js can't be loaded, the file
+ * isn't a v3 schema, or the query fails — every error is treated as "unknown
+ * truth", letting the caller fall back to the cached stats rather than masking
+ * a healthy DB as broken.
+ */
+async function countEmbeddedRowsFromDb(dbPath) {
+    try {
+        const { mofloImport } = await import('../services/moflo-require.js');
+        const initSqlJs = (await mofloImport('sql.js'))?.default;
+        if (!initSqlJs)
+            return null;
+        const SQL = await initSqlJs();
+        const buffer = readFileSync(dbPath);
+        const db = new SQL.Database(buffer);
+        try {
+            const res = db.exec("SELECT COUNT(*) FROM memory_entries WHERE embedding IS NOT NULL AND embedding != ''");
+            const cell = res?.[0]?.values?.[0]?.[0];
+            return typeof cell === 'number' ? cell : Number(cell ?? 0);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkEmbeddings() {
+    const liveDbPath = memoryDbCandidatePaths(process.cwd()).find((p) => existsSync(p));
+    // 1. Fast path: read cached vector-stats.json if available
+    const statsPath = join(process.cwd(), '.moflo', 'vector-stats.json');
+    try {
+        if (existsSync(statsPath)) {
+            const stats = JSON.parse(readFileSync(statsPath, 'utf8'));
+            const count = stats.vectorCount ?? 0;
+            const updatedAt = typeof stats.updatedAt === 'number' ? stats.updatedAt : 0;
+            const hasHnsw = stats.hasHnsw ?? false;
+            const dbSizeKB = stats.dbSizeKB ?? 0;
+            // Skew check (#639): cross-check the cached vectorCount against the actual
+            // DB; if they differ by more than VECTOR_STATS_SKEW_WARN_THRESHOLD, surface
+            // a stale-cache warning rather than displaying a wrong number on the
+            // statusline. Cheap signals first — opening memory.db via sql.js loads the
+            // whole file. Skip the open when the cache was clearly written after the
+            // last DB mutation (mtime check) AND the cached count is non-zero. The
+            // count===0 case keeps the open because that's the observed #639 failure
+            // mode (cache silently clobbered to zero).
+            let dbMtimeMs = 0;
+            if (liveDbPath) {
+                try {
+                    dbMtimeMs = statSync(liveDbPath).mtimeMs;
+                }
+                catch { /* missing — handled below */ }
+            }
+            const cacheNewerThanDb = updatedAt > 0 && dbMtimeMs > 0 && updatedAt >= dbMtimeMs;
+            if (liveDbPath && (count === 0 || !cacheNewerThanDb)) {
+                const liveCount = await countEmbeddedRowsFromDb(liveDbPath);
+                if (liveCount !== null) {
+                    const denom = Math.max(liveCount, 1);
+                    const skew = Math.abs(liveCount - count) / denom;
+                    if (skew > VECTOR_STATS_SKEW_WARN_THRESHOLD) {
+                        return {
+                            name: 'Embeddings',
+                            status: 'warn',
+                            message: `vector-stats cache is stale (cached ${count}, DB has ${liveCount} embedded rows — ${Math.round(skew * 100)}% skew)`,
+                            fix: 'node node_modules/moflo/bin/build-embeddings.mjs',
+                        };
+                    }
+                }
+            }
+            if (count === 0) {
+                return {
+                    name: 'Embeddings',
+                    status: 'warn',
+                    message: `Memory DB exists (${dbSizeKB} KB) but 0 vectors indexed — documents not embedded`,
+                    fix: 'npx moflo memory init --force && npx moflo embeddings init',
+                };
+            }
+            const hnswLabel = hasHnsw ? ', HNSW' : '';
+            return {
+                name: 'Embeddings',
+                status: 'pass',
+                message: `${count} vectors indexed (${dbSizeKB} KB${hnswLabel})`,
+            };
+        }
+    }
+    catch {
+        // Stats file unreadable — fall through to DB check
+    }
+    // 2. Check if memory DB file exists at all (reuse liveDbPath from above)
+    const foundDbPath = liveDbPath ?? null;
+    if (!foundDbPath) {
+        return {
+            name: 'Embeddings',
+            status: 'warn',
+            message: 'No memory database — embeddings not initialized',
+            fix: 'npx moflo memory init --force',
+        };
+    }
+    // 3. DB exists but no stats cache — try querying the DB for entry count
+    try {
+        const { checkMemoryInitialization } = await import('../memory/memory-initializer.js');
+        const info = await checkMemoryInitialization(foundDbPath);
+        if (!info.initialized) {
+            return {
+                name: 'Embeddings',
+                status: 'warn',
+                message: 'Memory DB exists but not properly initialized',
+                fix: 'npx moflo memory init --force',
+            };
+        }
+        const hasVectors = info.features?.vectorEmbeddings ?? false;
+        if (!hasVectors) {
+            return {
+                name: 'Embeddings',
+                status: 'warn',
+                message: `Memory DB initialized (v${info.version}) but no vector_indexes table`,
+                fix: 'npx moflo memory init --force && npx moflo embeddings init',
+            };
+        }
+        return {
+            name: 'Embeddings',
+            status: 'pass',
+            message: `Memory DB initialized (v${info.version}, vectors enabled)`,
+        };
+    }
+    catch (sqlJsError) {
+        // sql.js not available — fall back to file-size heuristic
+        const sqlDetail = errorDetail(sqlJsError);
+        try {
+            const stats = statSync(foundDbPath);
+            const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+            return {
+                name: 'Embeddings',
+                status: 'warn',
+                message: `Memory DB exists (${sizeMB} MB) — cannot verify vectors (sql.js not available: ${sqlDetail})`,
+                fix: 'npm install sql.js && npx moflo embeddings init',
+            };
+        }
+        catch (statError) {
+            return { name: 'Embeddings', status: 'warn', message: `Unable to check: sql.js failed (${sqlDetail}), stat failed (${errorDetail(statError)})` };
+        }
+    }
+}
+export async function checkSemanticQuality() {
+    try {
+        const { searchEntries } = await import('../memory/memory-initializer.js');
+        const result = await searchEntries({
+            query: 'test infrastructure health check',
+            namespace: 'patterns',
+            limit: 5,
+            threshold: 0.1,
+        });
+        if (!result.success || result.results.length === 0) {
+            return {
+                name: 'Semantic Quality',
+                status: 'warn',
+                message: 'No search results (empty database or no patterns namespace)',
+            };
+        }
+        const scores = result.results.map((r) => r.score);
+        const allSame = scores.every((s) => s === scores[0]);
+        const hasFallback = scores.some((s) => s === 0.5);
+        if (hasFallback) {
+            return {
+                name: 'Semantic Quality',
+                status: 'fail',
+                message: `${scores.length} results, scores include 0.500 fallback (keyword-only, no embeddings)`,
+                fix: 'Re-index with: npx moflo embeddings build --force',
+            };
+        }
+        if (allSame && scores.length > 1) {
+            return {
+                name: 'Semantic Quality',
+                status: 'warn',
+                message: `${scores.length} results, all scores identical (${scores[0].toFixed(3)}) — degraded search`,
+            };
+        }
+        const topScore = Math.max(...scores);
+        return {
+            name: 'Semantic Quality',
+            status: topScore >= 0.3 ? 'pass' : 'warn',
+            message: `${scores.length} results, top ${topScore.toFixed(3)}, varied (semantic search active)`,
+        };
+    }
+    catch (e) {
+        return {
+            name: 'Semantic Quality',
+            status: 'warn',
+            message: `Check failed: ${e instanceof Error ? e.message.split(/\r?\n/)[0] : 'error'}`,
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-memory.js.map