moflo 4.10.7 → 4.10.9

package/dist/src/cli/memory/intelligence.js

@@ -10,31 +10,30 @@
  *
  * @module v3/cli/intelligence
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { findProjectRoot } from '../services/project-root.js';
+import { MOFLO_DIR, mofloHomeDir } from '../services/moflo-paths.js';
 // ============================================================================
 // Persistence Configuration
 // ============================================================================
-/**
- * Get the data directory for neural pattern persistence
- * Uses .moflo/neural in the current working directory,
- * falling back to home directory
- */
+const NEURAL_SUBDIR = 'neural';
+const PATTERNS_FILE = 'patterns.json';
+const STATS_FILE = 'stats.json';
+// #1152: pre-fix builds wrote neural patterns to `~/.moflo/neural/` whenever
+// cwd lacked `.moflo`. The bleed was silent — every moflo-using project on
+// the machine shared one ReasoningBank. Resolver now anchors on
+// findProjectRoot() like neural-tools.ts (#829); legacy home-dir files are
+// copied (not moved) into the active project on first load so users do not
+// lose history when older co-installed projects still point at the home-dir
+// copy.
 function getDataDir() {
-    const cwd = process.cwd();
-    const localDir = join(cwd, '.moflo', 'neural');
-    const homeDir = join(homedir(), '.moflo', 'neural');
-    // Prefer local directory if .moflo exists
-    if (existsSync(join(cwd, '.moflo'))) {
-        return localDir;
-    }
-    return homeDir;
+    return join(findProjectRoot(), MOFLO_DIR, NEURAL_SUBDIR);
+}
+function getLegacyDataDir() {
+    return join(mofloHomeDir(), NEURAL_SUBDIR);
 }
-/**
- * Ensure the data directory exists
- */
 function ensureDataDir() {
     const dir = getDataDir();
     if (!existsSync(dir)) {
@@ -42,17 +41,36 @@ function ensureDataDir() {
     }
     return dir;
 }
-/**
- * Get the patterns file path
- */
 function getPatternsPath() {
-    return join(getDataDir(), 'patterns.json');
+    return join(getDataDir(), PATTERNS_FILE);
 }
-/**
- * Get the stats file path
- */
 function getStatsPath() {
-    return join(getDataDir(), 'stats.json');
+    return join(getDataDir(), STATS_FILE);
+}
+// Latch is intentionally not async-safe — all I/O in this module is
+// synchronous so re-entry only happens via clearIntelligence() in tests.
+let legacyMigrationAttempted = false;
+function migrateLegacyIfNeeded() {
+    if (legacyMigrationAttempted)
+        return;
+    legacyMigrationAttempted = true;
+    const legacyDir = getLegacyDataDir();
+    const localDir = getDataDir();
+    if (legacyDir === localDir)
+        return;
+    for (const file of [PATTERNS_FILE, STATS_FILE]) {
+        const legacy = join(legacyDir, file);
+        const local = join(localDir, file);
+        if (existsSync(legacy) && !existsSync(local)) {
+            try {
+                mkdirSync(localDir, { recursive: true });
+                copyFileSync(legacy, local);
+            }
+            catch {
+                // Best-effort migration; failures fall through to a fresh local store.
+            }
+        }
+    }
 }
 // ============================================================================
 // Default Configuration
@@ -173,6 +191,7 @@ class LocalReasoningBank {
      */
     loadFromDisk() {
         try {
+            migrateLegacyIfNeeded();
             const path = getPatternsPath();
             if (existsSync(path)) {
                 const data = JSON.parse(readFileSync(path, 'utf-8'));
@@ -207,6 +226,13 @@ class LocalReasoningBank {
      * Immediately flush patterns to disk
      */
     flushToDisk() {
+        // Cancel any pending debounced save — we are writing right now and the
+        // deferred handler would otherwise fire post-teardown on short-lived
+        // processes (test runners hit this as a Windows EPERM during cleanup).
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+            this.saveTimeout = null;
+        }
         if (!this.persistenceEnabled || !this.dirty)
             return;
         try {
@@ -368,6 +394,7 @@ let globalStats = {
  */
 function loadPersistedStats() {
     try {
+        migrateLegacyIfNeeded();
         const path = getStatsPath();
         if (existsSync(path)) {
             const data = JSON.parse(readFileSync(path, 'utf-8'));
@@ -605,6 +632,7 @@ export function clearIntelligence() {
     sonaCoordinator = null;
     reasoningBank = null;
     intelligenceInitialized = false;
+    legacyMigrationAttempted = false;
     globalStats = {
         trajectoriesRecorded: 0,
         lastAdaptation: null

package/dist/src/cli/memory/memory-initializer.js

@@ -2220,32 +2220,42 @@ export async function deleteEntry(options) {
     }
 }
 /**
- * Get per-namespace entry counts via a single GROUP BY query.
- * Returns { namespaces: Record<string, number>, total: number }.
+ * Get memory stats via a single GROUP BY query — namespace counts plus the
+ * number of rows that carry a non-null embedding. One trip to disk; the
+ * server-side aggregation replaces a pre-#1149 client iteration that
+ * fetched 100 000 rows just to count them.
+ *
+ * Throws on DB read errors. Returns a zero shape ONLY when the DB file
+ * doesn't exist yet (the real "empty project" signal) — never swallows a
+ * locked/corrupt-DB error into a fake zero, since that's the exact silent
+ * wrong-answer this fix is for.
  */
 export async function getNamespaceCounts(dbPath) {
     const resolvedPath = dbPath || memoryDbPath(process.cwd());
+    if (!fs.existsSync(resolvedPath)) {
+        return { namespaces: {}, total: 0, withEmbeddings: 0 };
+    }
+    const db = openDaemonDatabase(resolvedPath);
     try {
-        if (!fs.existsSync(resolvedPath)) {
-            return { namespaces: {}, total: 0 };
-        }
-        const db = openDaemonDatabase(resolvedPath);
-        const result = db.exec("SELECT namespace, COUNT(*) as cnt FROM memory_entries WHERE status = 'active' GROUP BY namespace ORDER BY cnt DESC");
-        db.close();
+        const result = db.exec("SELECT namespace, COUNT(*) AS cnt, SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) AS emb_cnt " +
+            "FROM memory_entries WHERE status = 'active' GROUP BY namespace ORDER BY cnt DESC");
         const namespaces = {};
         let total = 0;
+        let withEmbeddings = 0;
         if (result[0]?.values) {
             for (const row of result[0].values) {
                 const ns = String(row[0]);
                 const count = Number(row[1]);
+                const embCount = Number(row[2] ?? 0);
                 namespaces[ns] = count;
                 total += count;
+                withEmbeddings += embCount;
             }
         }
-        return { namespaces, total };
+        return { namespaces, total, withEmbeddings };
     }
-    catch {
-        return { namespaces: {}, total: 0 };
+    finally {
+        db.close();
     }
 }
 export default {

package/dist/src/cli/movector/model-router.js

@@ -80,7 +80,7 @@ const DEFAULT_CONFIG = {
     maxUncertainty: 0.15,
     enableCircuitBreaker: true,
     circuitBreakerThreshold: 5,
-    statePath: '.swarm/model-router-state.json',
+    statePath: '.moflo/movector/model-router-state.json',
     autoSaveInterval: 1, // Save after every decision for CLI persistence
     enableCostOptimization: true,
     preferSpeed: true,

package/dist/src/cli/movector/q-learning-router.js

@@ -9,7 +9,7 @@
  * - Optimized state space with feature hashing
  * - Epsilon decay with exponential annealing
  * - Experience replay buffer for stable learning
- * - Model persistence to .swarm/q-learning-model.json
+ * - Model persistence to .moflo/movector/q-learning-model.json
  *
  * @module q-learning-router
  */
@@ -32,7 +32,7 @@ const DEFAULT_CONFIG = {
     enableReplay: true,
     cacheSize: 256,
     cacheTTL: 300000,
-    modelPath: '.swarm/q-learning-model.json',
+    modelPath: '.moflo/movector/q-learning-model.json',
     autoSaveInterval: 100,
     stateSpaceDim: 64,
 };

package/dist/src/cli/services/daemon-dashboard.js

@@ -16,7 +16,18 @@ import { createServer } from 'node:http';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { handleMemoryStore, handleMemoryDelete, handleMemoryBatch, handleMemoryGet, handleMemorySearch, handleMemoryList, matchMemoryRpcRoute, } from './daemon-memory-rpc.js';
 import { aggregateClaudeStats, emptyClaudeStatsShape } from './claude-stats.js';
-export const DEFAULT_DASHBOARD_PORT = 3117;
+import { serverPortCandidates, LEGACY_DEFAULT_PORT } from './daemon-port.js';
+import { writeLockPort } from './daemon-lock.js';
+import { findProjectRoot } from './project-root.js';
+import { readOwnMofloVersion } from './daemon-lock.js';
+/**
+ * Legacy default port retained as a re-export of {@link LEGACY_DEFAULT_PORT}
+ * for backward compat with existing importers (`commands/daemon.ts`,
+ * `__tests__/daemon-dashboard.test.ts`). The actual port a daemon binds is
+ * now resolved deterministically per project via `serverPortCandidates()` —
+ * see `daemon-port.ts` and `docs/internal/1145-daemon-port-collision-analysis.md`.
+ */
+export const DEFAULT_DASHBOARD_PORT = LEGACY_DEFAULT_PORT;
 /**
  * Process-wide promise for the shared MemoryAccessor. Memoized as a *promise*
  * (not the resolved value) so concurrent first-callers share a single init
@@ -129,6 +140,27 @@ function tryParseSafe(s) {
         return s;
     }
 }
+/**
+ * Build the `/api/health` response (#1145).
+ *
+ * Identity payload — clients compare `projectRoot` against their own
+ * `findProjectRoot()` and refuse to route to this daemon on mismatch.
+ * Also surfaces `pid`, `version`, and `uptimeMs` for healer-class
+ * diagnostics and orphan-daemon detection.
+ *
+ * Read-only, no-auth, localhost-only (the dashboard binds 127.0.0.1).
+ */
+function handleHealth(daemon, opts) {
+    const status = daemon.getStatus();
+    const startedAt = status.startedAt instanceof Date ? status.startedAt : null;
+    return {
+        status: 'ok',
+        projectRoot: opts.projectRoot ?? findProjectRoot(),
+        pid: status.pid ?? process.pid,
+        version: readOwnMofloVersion() ?? null,
+        uptimeMs: startedAt ? Date.now() - startedAt.getTime() : 0,
+    };
+}
 function handleStatus(daemon) {
     const status = daemon.getStatus();
     // Index config rows by worker type so the row renderer can show a
@@ -244,15 +276,18 @@ function tryParse(s) {
     }
 }
 async function handleMemoryStats() {
-    // Single GROUP BY query — no hardcoded namespace list, no row fetching
-    try {
-        const { getNamespaceCounts } = await import('../memory/memory-initializer.js');
-        const { namespaces, total } = await getNamespaceCounts();
-        return { namespaces, totalEntries: total, available: total > 0 || Object.keys(namespaces).length > 0 };
-    }
-    catch {
-        return { namespaces: {}, totalEntries: 0, available: false };
-    }
+    // Single GROUP BY query — no hardcoded namespace list, no row fetching.
+    // Errors propagate to the request handler's outer try/catch → 500, so
+    // MCP clients see a real failure instead of a silent `totalEntries: 0`.
+    const { getNamespaceCounts } = await import('../memory/memory-initializer.js');
+    const { namespaces, total, withEmbeddings } = await getNamespaceCounts();
+    return {
+        ok: true,
+        namespaces,
+        totalEntries: total,
+        withEmbeddings,
+        available: total > 0 || Object.keys(namespaces).length > 0,
+    };
 }
 /**
  * Build the `/api/claude-stats` response (#1044).
@@ -433,6 +468,11 @@ async function handleRequest(req, res, daemon, opts) {
         if (url === '/') {
             sendHtml(res, DASHBOARD_HTML);
         }
+        else if (url === '/api/health') {
+            // #1145 — identity probe. Clients use this to confirm they're talking
+            // to the daemon for their OWN project before routing memory ops here.
+            sendJson(res, 200, handleHealth(daemon, opts));
+        }
         else if (url === '/api/status') {
             sendJson(res, 200, handleStatus(daemon));
         }
@@ -588,33 +628,62 @@ const MAX_PORT_ATTEMPTS = 10;
 /**
  * Start the dashboard HTTP server.
  *
- * Tries the requested port first, then falls back to port+1, port+2, ...
- * up to MAX_PORT_ATTEMPTS to avoid crashing the daemon when another
- * project's daemon already holds the default port.
+ * Port selection (#1145):
+ *   1. `opts.port`, if explicitly set (CLI `--dashboard-port` flag).
+ *   2. Otherwise `serverPortCandidates(projectRoot)` — deterministic per-
+ *      project port + collision-fallback range.
+ * Both honor `MOFLO_DAEMON_PORT` (collapses the candidate list to one).
+ *
+ * On successful bind the bound port is stamped into `.moflo/daemon.lock`
+ * via `writeLockPort()` so clients can discover it without guessing.
  *
- * @param daemon - WorkerDaemon instance for status data
- * @param opts - Dashboard configuration
- * @returns A handle to stop the server (port reflects the actual bound port)
+ * On bind exhaustion (every candidate in use) the server throws — the
+ * caller is expected to surface the failure rather than stay half-alive
+ * (the silent-trap pattern that produced #1145).
+ *
+ * @returns handle whose `.port` field reflects the actually bound port
  */
 export async function startDashboard(daemon, opts) {
-    const basePort = opts.port;
-    for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
-        const port = basePort + attempt;
+    const projectRoot = opts.projectRoot ?? findProjectRoot();
+    const candidates = buildBindCandidates(opts.port, projectRoot, MAX_PORT_ATTEMPTS);
+    let lastErr = null;
+    for (let i = 0; i < candidates.length; i++) {
+        const port = candidates[i];
         try {
-            const handle = await tryListenOnPort(daemon, opts, port);
+            const handle = await tryListenOnPort(daemon, { ...opts, projectRoot }, port);
+            // Stamp the bound port into the lock so clients discover us reliably.
+            // Best-effort: a missing/locked-by-another-pid lock means stamping
+            // is a no-op — the deterministic fallback still works.
+            try {
+                writeLockPort(projectRoot, handle.port);
+            }
+            catch { /* ignore */ }
             return handle;
         }
         catch (err) {
+            lastErr = err;
             const code = err && typeof err === 'object' && 'code' in err ? err.code : '';
-            if (code === 'EADDRINUSE' && attempt < MAX_PORT_ATTEMPTS - 1) {
-                // Port taken — try the next one
+            if (code === 'EADDRINUSE' && i < candidates.length - 1)
                 continue;
-            }
             throw err;
         }
     }
-    // Should be unreachable, but satisfies the type checker
-    throw new Error(`All dashboard ports ${basePort}–${basePort + MAX_PORT_ATTEMPTS - 1} are in use`);
+    // Bind exhaustion — surface so the daemon can hard-fail (#1145 §9.4).
+    throw lastErr ?? new Error(`All dashboard ports (${candidates[0]}…${candidates[candidates.length - 1]}) are in use`);
+}
+/**
+ * Build the ordered list of ports to try.
+ *
+ * When the caller pinned a port (CLI flag), respect it without any
+ * fallback — the consumer pinned it on purpose. When they didn't, use
+ * the deterministic per-project candidates so two projects never collide
+ * silently on a fixed default.
+ */
+function buildBindCandidates(explicitPort, projectRoot, maxAttempts) {
+    if (typeof explicitPort === 'number' && explicitPort > 0 && explicitPort < 65536) {
+        return [explicitPort];
+    }
+    return serverPortCandidates(projectRoot, maxAttempts);
 }
 /**
  * Attempt to bind the dashboard server to a specific port.