moflo 4.10.10 → 4.10.12

package/README.md

@@ -419,7 +419,7 @@ flo daemon status    # shows whether the service is registered AND running
 
 `flo spell schedule create` warns when the daemon isn't installed so you don't quietly miss runs.
 
-**Monitoring.** **The Luminarium** (the moflo daemon's localhost UI) surfaces live schedules, recent executions, and per-schedule controls (disable / re-enable / run now). It starts alongside the daemon at `http://localhost:3117` (override with `--dashboard-port` or disable with `--no-dashboard`).
+**Monitoring.** **[The Luminarium](#the-luminarium)** — moflo's localhost daemon dashboard — surfaces live schedules, recent executions, and per-schedule controls (disable / re-enable / run now), alongside worker health, memory stats, and Claude Code session stats. Each project gets its own deterministic port (33000–33999) recorded in `.moflo/daemon.lock`; ask `/luminarium` in your Claude session and it'll print the link.
 
 For full configuration (`scheduler:` block in `moflo.yaml`), event types, and the catch-up window after restarts, see [docs/SPELLS.md#scheduling](docs/SPELLS.md#scheduling).
 
@@ -459,6 +459,35 @@ flo epic reset 42                        # Reset state for re-run
 
 See the [Epic handling](#epic-handling) section above for detection criteria and the comparison between `/flo <epic>` and `flo epic run`.
 
+## The Luminarium
+
+The Luminarium is moflo's localhost daemon dashboard. It boots automatically with the background daemon (no extra service to install) and stays running as long as the daemon is up.
+
+### Finding the URL
+
+Each project gets a deterministic port in the range 33000–33999, derived from a hash of the project root so two projects never collide on the same machine. The actual bound port is written to `.moflo/daemon.lock` when the daemon starts — if the deterministic port is already taken the daemon scans forward, so the lock file is the source of truth, not the hash.
+
+Three ways to get the URL:
+
+- **`/luminarium`** — inside a Claude Code session in a moflo project, this skill reads `.moflo/daemon.lock` and prints `http://localhost:<port>`. Fastest path.
+- **`flo daemon status`** — prints the URL alongside the health summary.
+- **`cat .moflo/daemon.lock`** — read the JSON directly: `{ "pid": ..., "port": 33421, ... }`.
+
+### What it shows
+
+| Tab | What you see |
+|-----|--------------|
+| **Workers** | Live agent processes the daemon is running (statusline updater, indexer, embedder, etc.) |
+| **Schedules** | All registered spell schedules (cron / interval / one-time), with run-now and disable controls |
+| **Executions** | Recent spell runs — duration, exit code, step-by-step output |
+| **Memory** | Memory namespace breakdown, vector count, embedder backend, HNSW index health |
+| **Claude Stats** | Per-session Claude Code transcript stats — tokens, tools called, files touched (local primary sessions only) |
+
+### Flags
+
+- `flo daemon start --no-dashboard` — disable the HTTP server entirely (the daemon itself still runs)
+- `flo daemon start --dashboard-port <N>` — pin to a specific port, overriding the deterministic resolver. Also accepts the `MOFLO_DAEMON_PORT` env var, which the rest of moflo respects when talking to the daemon
+
 ## Commands
 
 You don't need to run these for normal use — `flo init` sets everything up, and the hooks handle memory, routing, and learning automatically. These commands are here for manual setup, debugging, and tweaking.

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

@@ -272,6 +272,12 @@ export async function checkMemoryDatabase() {
  *  - `memory.db` / `memory.db.bak` — stale once `.moflo/moflo.db` exists.
  *  - `q-learning-model.json` / `model-router-state.json` — live router state
  *    that pre-dates the `.moflo/movector/` defaults; migrate, don't delete.
+ *  - `lora-weights.json` / `moe-weights.json` — LoRA + MoE weights (#1168
+ *    moved the writers to `.moflo/movector/`).
+ *  - `ewc-fisher.json` / `sona-patterns.json` — neural runtime state (#1168
+ *    moved the writers to `.moflo/neural/`).
+ *  - `state.json` — `flo swarm init` snapshot (#1168 → `.moflo/swarm/`).
+ *  - `code-map-hash.txt` — `flo memory code-map` cache (#1168 → `.moflo/memory/`).
  *  - `hooks.log` / `background.log` — diagnostic logs the launcher used to
  *    route to `.swarm/`; relocate to `.moflo/logs/`.
  *
@@ -291,6 +297,12 @@ export async function checkSwarmResidue() {
         'memory.db.bak',
         'q-learning-model.json',
         'model-router-state.json',
+        'lora-weights.json',
+        'moe-weights.json',
+        'ewc-fisher.json',
+        'sona-patterns.json',
+        'state.json',
+        'code-map-hash.txt',
         'hooks.log',
         'background.log',
     ];

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

@@ -26,6 +26,7 @@ import { existsSync } from 'fs';
 import { errorDetail } from '../shared/utils/error-detail.js';
 import { memoryDbPath } from '../services/moflo-paths.js';
 import { findProjectRoot } from '../services/project-root.js';
+import { purgeMemoryProbeNamespaces } from '../services/ephemeral-namespace-purge.js';
 import { loadToolArrays, getTool, pushDetail, summarizeFunctional, } from './doctor-checks-functional-shared.js';
 const MEMORY_ACCESS_CHECK = 'Memory Access Functional';
 const MEMORY_ACCESS_FAIL_FIX = 'Run `flo doctor --json` for per-subcheck details. Common fixes: ensure fastembed installed (memory_store.hasEmbedding=false), explicit threshold:0 honored (#837), or rebuild HNSW index (`flo memory rebuild-index`)';
@@ -563,6 +564,12 @@ export async function checkMemoryAccessFunctional() {
             }
             catch { /* ignore */ }
         }
+        // #1166 — namespace-level sweep backstop for the per-key safeDelete
+        // loop above (see purgeMemoryProbeNamespaces docstring for why).
+        try {
+            await purgeMemoryProbeNamespaces({ dbPath: memoryDbPath(findProjectRoot()) });
+        }
+        catch { /* best-effort */ }
     }
     return summarizeFunctional(MEMORY_ACCESS_CHECK, details, {
         passSuffix: '(memory_store + memory_search round-trip verified across subagent, swarm-agent, and hive-mind contexts)',

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

@@ -152,10 +152,27 @@ async function fixSwarmLegacyResidue() {
             allMigrated = false;
         }
     }
-    // (2) router state JSONs — rename into .moflo/movector/.
+    // (2) router state + neural state JSONs — rename into .moflo/{movector,neural,swarm,memory}/.
+    //
+    // q-learning-model.json + model-router-state.json: shipped at #727.
+    // lora-weights.json + moe-weights.json: writer relocation in #1168
+    //   (lora-adapter.ts, moe-router.ts).
+    // ewc-fisher.json + sona-patterns.json: writer relocation in #1168
+    //   (ewc-consolidation.ts, sona-optimizer.ts).
+    // state.json + code-map-hash.txt: writer relocation in #1168
+    //   (commands/swarm.ts, commands/memory.ts).
+    const neuralDir = join(moflo, 'neural');
+    const swarmStateDir = join(moflo, 'swarm');
+    const memoryStateDir = join(moflo, 'memory');
     const stateFiles = [
         { name: 'q-learning-model.json', dest: movectorDir },
         { name: 'model-router-state.json', dest: movectorDir },
+        { name: 'lora-weights.json', dest: movectorDir },
+        { name: 'moe-weights.json', dest: movectorDir },
+        { name: 'ewc-fisher.json', dest: neuralDir },
+        { name: 'sona-patterns.json', dest: neuralDir },
+        { name: 'state.json', dest: swarmStateDir },
+        { name: 'code-map-hash.txt', dest: memoryStateDir },
     ];
     for (const { name, dest } of stateFiles) {
         const src = join(swarmDir, name);
@@ -230,10 +247,11 @@ export async function autoFixCheck(check) {
     // Map checks to programmatic fixes (not just shell commands)
     const fixActions = {
         'Memory Database': async () => {
+            // Canonical DB lives at `.moflo/moflo.db`; `initializeMemoryDatabase`
+            // creates the parent dir itself. The pre-#1168 fix also `mkdirSync`'d
+            // `.swarm/` — vestigial residue that fought the 'Swarm Residue' fix in
+            // the same healer pass. Removed.
             try {
-                const swarmDir = join(process.cwd(), '.swarm');
-                if (!existsSync(swarmDir))
-                    mkdirSync(swarmDir, { recursive: true });
                 const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
                 const result = await initializeMemoryDatabase({ force: true, verbose: false });
                 return result.success;
@@ -243,12 +261,11 @@ export async function autoFixCheck(check) {
             }
         },
         'Embeddings': async () => {
+            // Same fix as Memory Database — ensure the canonical DB exists, then
+            // populate embeddings. Pre-#1168 wrote to `.swarm/memory.db` directly,
+            // contradicting the post-#727 layout; that branch is removed.
             try {
-                const swarmDir = join(process.cwd(), '.swarm');
-                if (!existsSync(swarmDir))
-                    mkdirSync(swarmDir, { recursive: true });
-                const dbPath = join(swarmDir, 'memory.db');
-                if (!existsSync(dbPath)) {
+                if (!existsSync(memoryDbPath(findProjectRoot()))) {
                     const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
                     await initializeMemoryDatabase({ force: true, verbose: false });
                 }

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

@@ -9,6 +9,7 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { legacySwarmPath, runtimePath } from '../services/moflo-paths.js';
 // Memory backends
 const BACKENDS = [
     { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
@@ -2129,7 +2130,10 @@ const codeMapCommand = {
         const { execSync } = await import('child_process');
         const { createHash } = await import('crypto');
         const cwd = ctx.cwd || process.cwd();
-        const hashCachePath = pathModule.join(cwd, '.swarm', 'code-map-hash.txt');
+        // Post-#1168: canonical at `.moflo/memory/code-map-hash.txt`. Legacy
+        // `.swarm/code-map-hash.txt` is read-only fallback for upgrade scenarios.
+        const hashCachePath = runtimePath('memory', 'code-map-hash.txt');
+        const legacyHashCachePath = legacySwarmPath('code-map-hash.txt');
         output.writeln();
         output.writeln(output.bold('Generating Code Map'));
         output.writeln(output.dim('─'.repeat(50)));
@@ -2168,9 +2172,12 @@ const codeMapCommand = {
             output.writeln(`File list hash: ${currentHash.slice(0, 12)}...`);
             return { success: true };
         }
-        // Check if unchanged
-        if (!forceRegen && fs.existsSync(hashCachePath)) {
-            const cached = fs.readFileSync(hashCachePath, 'utf-8').trim();
+        // Check if unchanged — canonical first, then legacy `.swarm/` fallback.
+        const cachedReadPath = fs.existsSync(hashCachePath)
+            ? hashCachePath
+            : (fs.existsSync(legacyHashCachePath) ? legacyHashCachePath : null);
+        if (!forceRegen && cachedReadPath) {
+            const cached = fs.readFileSync(cachedReadPath, 'utf-8').trim();
             if (cached === currentHash) {
                 const { db } = await openDb(cwd);
                 const stmt = db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE namespace = ?`);

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

@@ -7,14 +7,26 @@ import { select, confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
+import { LEGACY_SWARM_DIR, memoryDbCandidatePaths, mofloDir } from '../services/moflo-paths.js';
+import { findProjectRoot } from '../services/project-root.js';
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const projectRoot = findProjectRoot();
+    // `.moflo/swarm/state.json` is canonical post-#1168; `.swarm/state.json`
+    // is a read-only fallback so a consumer who initialised on an older moflo
+    // still sees their swarm. The pre-#1168 agents/tasks JSON probe blocks
+    // were removed — no current writer creates those directories, so they
+    // always produced 0 counts. The coordinator-backed MCP tools
+    // (agent_list / task_list) are the live source of truth.
+    const canonicalSwarmDir = path.join(mofloDir(projectRoot), 'swarm');
+    const legacySwarmDir = path.join(projectRoot, LEGACY_SWARM_DIR);
     const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
     const memoryPaths = memoryDbCandidatePaths(process.cwd());
-    // Check for active swarm state file
-    const swarmStateFile = path.join(swarmDir, 'state.json');
+    // Check for active swarm state file — canonical first, then legacy.
+    let swarmStateFile = path.join(canonicalSwarmDir, 'state.json');
+    if (!fs.existsSync(swarmStateFile)) {
+        swarmStateFile = path.join(legacySwarmDir, 'state.json');
+    }
     let swarmState = null;
     if (fs.existsSync(swarmStateFile)) {
         try {
@@ -24,30 +36,14 @@ function getSwarmStatus(swarmId) {
             // Ignore parse errors
         }
     }
-    // Count active agents from process files
-    let activeAgents = 0;
-    let totalAgents = 0;
-    const agentsDir = path.join(swarmDir, 'agents');
-    if (fs.existsSync(agentsDir)) {
-        try {
-            const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.json'));
-            totalAgents = agentFiles.length;
-            for (const file of agentFiles) {
-                try {
-                    const agent = JSON.parse(fs.readFileSync(path.join(agentsDir, file), 'utf-8'));
-                    if (agent.status === 'active' || agent.status === 'running') {
-                        activeAgents++;
-                    }
-                }
-                catch {
-                    // Ignore
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
+    // agents/tasks counters: no file-store readers post-#1168. Coordinator
+    // MCP tools own the live counts; getSwarmStatus surfaces a static summary
+    // of the persisted state file plus session/memory rough indicators.
+    const activeAgents = 0;
+    const totalAgents = 0;
+    const completedTasks = 0;
+    const inProgressTasks = 0;
+    const pendingTasks = 0;
     // Get session count
     let sessionCount = 0;
     if (fs.existsSync(sessionDir)) {
@@ -71,36 +67,6 @@ function getSwarmStatus(swarmId) {
             }
         }
     }
-    // Count task files if they exist
-    let completedTasks = 0;
-    let inProgressTasks = 0;
-    let pendingTasks = 0;
-    const tasksDir = path.join(swarmDir, 'tasks');
-    if (fs.existsSync(tasksDir)) {
-        try {
-            const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
-            for (const file of taskFiles) {
-                try {
-                    const task = JSON.parse(fs.readFileSync(path.join(tasksDir, file), 'utf-8'));
-                    if (task.status === 'completed' || task.status === 'done') {
-                        completedTasks++;
-                    }
-                    else if (task.status === 'in_progress' || task.status === 'running') {
-                        inProgressTasks++;
-                    }
-                    else {
-                        pendingTasks++;
-                    }
-                }
-                catch {
-                    // Ignore
-                }
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
     // Calculate dynamic progress based on actual state
     // If no swarm state, show 0%. Otherwise calculate from completed tasks
     const totalTasks = completedTasks + inProgressTasks + pendingTasks;
@@ -279,8 +245,11 @@ const initCommand = {
             });
             output.writeln();
             output.printSuccess('Swarm initialized successfully');
-            // Save swarm state locally for status command to read
-            const swarmDir = path.join(process.cwd(), '.swarm');
+            // Save swarm state locally for status command to read. Post-#1168 the
+            // canonical home is `<root>/.moflo/swarm/state.json`; the legacy
+            // `.swarm/state.json` path is preserved as a read-only fallback in
+            // `getSwarmStatus`.
+            const swarmDir = path.join(mofloDir(findProjectRoot()), 'swarm');
             try {
                 if (!fs.existsSync(swarmDir)) {
                     fs.mkdirSync(swarmDir, { recursive: true });

package/dist/src/cli/memory/bridge-embedder.js

@@ -116,13 +116,16 @@ export const PURGE_ON_SESSION_START_NAMESPACES = new Set([
  *   spawns a NEW namespace, so namespace pollution grows linearly with
  *   healer-run count if cleanup races fail.
  *
- * Both probes register an explicit cleanup via `safeDelete`, but the
- * cleanup is best-effort and silently swallows failures (e.g. daemon
- * races, MCP transport errors) — so rows accumulate across consumer
- * sessions. Auto-purging matches the pattern for
- * `hive-mind`/`epic-state`/`test-bridge-fix`. These rows MUST still get
- * embeddings (see {@link EPHEMERAL_NAMESPACE_PREFIXES} for why) — only
- * their persistence across sessions is curtailed.
+ * Both probes register an explicit cleanup via `safeDelete`. Post-#1166
+ * the doctor also runs an in-process namespace sweep over these prefixes
+ * inside `checkMemoryAccessFunctional`'s finally block, so a healthy
+ * doctor run leaves zero rows behind. The session-start launcher's
+ * prefix-purge is now strictly a safety net for crashed-process residue
+ * (the doctor never reached its finally) or pre-#1166 consumer DBs that
+ * still carry accumulated probe rows. Auto-purging matches the pattern
+ * for `hive-mind`/`epic-state`/`test-bridge-fix`. These rows MUST still
+ * get embeddings (see {@link EPHEMERAL_NAMESPACE_PREFIXES} for why) —
+ * only their persistence across sessions is curtailed.
  */
 export const PURGE_ON_SESSION_START_PREFIXES = new Set([
     'doctor-memprobe-',

package/dist/src/cli/memory/ewc-consolidation.js

@@ -16,13 +16,15 @@
  * - Fisher Information Matrix computation from gradient history
  * - Online EWC updates for streaming patterns
  * - Selective consolidation based on pattern importance
- * - Persistent storage in .swarm/ewc-fisher.json
+ * - Persistent storage in .moflo/neural/ewc-fisher.json
+ *   (legacy fallback read: .swarm/ewc-fisher.json)
  *
  * @module v3/cli/memory/ewc-consolidation
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { errorDetail } from '../shared/utils/error-detail.js';
+import { legacySwarmPath, runtimePath } from '../services/moflo-paths.js';
 // ============================================================================
 // Default Configuration
 // ============================================================================
@@ -31,7 +33,6 @@ const DEFAULT_EWC_CONFIG = {
     maxPatterns: 1000,
     fisherDecayRate: 0.01,
     importanceThreshold: 0.3,
-    storagePath: path.join(process.cwd(), '.swarm', 'ewc-fisher.json'),
     onlineMode: true,
     dimensions: 384
 };
@@ -51,7 +52,15 @@ export class EWCConsolidator {
     consolidationHistory = [];
     initialized = false;
     constructor(config) {
-        this.config = { ...DEFAULT_EWC_CONFIG, ...config };
+        // Resolve storagePath lazily here (#1168) — the default routes through
+        // findProjectRoot at construct-time, not module-load time. Default-rescue
+        // runs *last* so an explicit `storagePath: undefined` falls back to the
+        // canonical path instead of leaving the field undefined.
+        this.config = {
+            ...DEFAULT_EWC_CONFIG,
+            ...config,
+            storagePath: config?.storagePath ?? runtimePath('neural', 'ewc-fisher.json'),
+        };
         this.globalFisher = new Array(this.config.dimensions).fill(0);
     }
     /**
@@ -447,10 +456,17 @@ export class EWCConsolidator {
      * Load state from disk
      */
     async loadFromDisk() {
-        if (!fs.existsSync(this.config.storagePath)) {
-            throw new Error('No persisted state found');
+        // Canonical path first, then legacy `.swarm/ewc-fisher.json` as a
+        // read-only fallback for consumers who upgraded mid-training (#1168).
+        let sourcePath = this.config.storagePath;
+        if (!fs.existsSync(sourcePath)) {
+            const legacy = legacySwarmPath('ewc-fisher.json');
+            if (!fs.existsSync(legacy)) {
+                throw new Error('No persisted state found');
+            }
+            sourcePath = legacy;
         }
-        const content = fs.readFileSync(this.config.storagePath, 'utf-8');
+        const content = fs.readFileSync(sourcePath, 'utf-8');
         const state = JSON.parse(content);
         // Validate version
         if (state.version !== '1.0.0') {

package/dist/src/cli/memory/sona-optimizer.js

@@ -8,17 +8,18 @@
  * - Processes trajectory outcomes from the spell-engine trajectory pipeline
  * - Extracts keywords from tasks for pattern matching
  * - Maintains learned routing patterns with confidence scoring
- * - Persists patterns to .swarm/sona-patterns.json
+ * - Persists patterns to .moflo/neural/sona-patterns.json
+ *   (legacy fallback read: .swarm/sona-patterns.json)
  * - Integrates with Q-learning router for combined routing
  *
  * @module v3/cli/memory/sona-optimizer
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
+import { dirname, isAbsolute, resolve } from 'path';
+import { legacySwarmPath, runtimePath } from '../services/moflo-paths.js';
 // ============================================================================
 // Constants
 // ============================================================================
-const DEFAULT_PERSISTENCE_PATH = '.swarm/sona-patterns.json';
 const PATTERN_VERSION = '1.0.0';
 const MIN_CONFIDENCE = 0.1;
 const MAX_CONFIDENCE = 0.99;
@@ -105,7 +106,12 @@ export class SONAOptimizer {
     qLearningRouter = null;
     qLearningEnabled = false;
     constructor(options) {
-        this.persistencePath = options?.persistencePath || DEFAULT_PERSISTENCE_PATH;
+        // Resolve persistencePath lazily here (#1168). When the caller supplies
+        // one we honor it verbatim (may be relative — preserved for existing
+        // tests/callers that join against their own cwd). When unset, we route
+        // through runtimePath so writes land under `.moflo/neural/` regardless
+        // of subprocess cwd.
+        this.persistencePath = options?.persistencePath || runtimePath('neural', 'sona-patterns.json');
     }
     /**
      * Initialize the optimizer and load persisted state
@@ -499,9 +505,17 @@ export class SONAOptimizer {
      */
     loadFromDisk() {
         try {
-            const fullPath = join(process.cwd(), this.persistencePath);
+            // Treat absolute persistencePath verbatim (new #1168 default routes
+            // through runtimePath → absolute `.moflo/neural/...`); relative paths
+            // preserve the pre-#1168 behaviour of resolving against cwd.
+            let fullPath = isAbsolute(this.persistencePath)
+                ? this.persistencePath
+                : resolve(process.cwd(), this.persistencePath);
             if (!existsSync(fullPath)) {
-                return false;
+                const legacy = legacySwarmPath('sona-patterns.json');
+                if (!existsSync(legacy))
+                    return false;
+                fullPath = legacy;
             }
             const data = readFileSync(fullPath, 'utf-8');
             const state = JSON.parse(data);
@@ -536,7 +550,11 @@ export class SONAOptimizer {
      */
     saveToDisk() {
         try {
-            const fullPath = join(process.cwd(), this.persistencePath);
+            // See loadFromDisk: absolute persistencePath is taken verbatim, relative
+            // paths resolve against cwd. New #1168 default writes to `.moflo/neural/`.
+            const fullPath = isAbsolute(this.persistencePath)
+                ? this.persistencePath
+                : resolve(process.cwd(), this.persistencePath);
             const dir = dirname(fullPath);
             // Ensure directory exists
             if (!existsSync(dir)) {

package/dist/src/cli/movector/lora-adapter.js

@@ -8,7 +8,7 @@
  * - Rank decomposition (r << d) for memory efficiency
  * - Additive weight updates: W' = W + BA (where B ∈ R^{d×r}, A ∈ R^{r×k})
  * - Support for multiple adaptation heads
- * - Persistence to .swarm/lora-weights.json
+ * - Persistence to .moflo/movector/lora-weights.json (legacy fallback: .swarm/lora-weights.json)
  *
  * Memory savings:
  * - Original: d × k parameters
@@ -18,7 +18,8 @@
  * @module lora-adapter
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
+import { dirname } from 'path';
+import { legacySwarmPath, runtimePath } from '../services/moflo-paths.js';
 // ============================================================================
 // Types & Constants
 // ============================================================================
@@ -47,7 +48,6 @@ const DEFAULT_CONFIG = {
     inputDim: INPUT_DIM,
     outputDim: OUTPUT_DIM,
     learningRate: 0.001,
-    weightsPath: join(process.cwd(), '.swarm', 'lora-weights.json'),
     enableDropout: true,
     dropoutProb: 0.1,
     autoSaveInterval: 50,
@@ -67,7 +67,16 @@ export class LoRAAdapter {
     lastUpdate = null;
     updatesSinceLastSave = 0;
     constructor(config) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Resolve weightsPath lazily here, not at module load — captures the
+        // *current* consumer project root, not the cwd at first import (#1168).
+        // Default-rescue runs *last* so an explicit `weightsPath: undefined` from
+        // the caller still falls back to the canonical path instead of crashing
+        // save/load on an undefined string.
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            weightsPath: config?.weightsPath ?? runtimePath('movector', 'lora-weights.json'),
+        };
         this.weights = this.initializeWeights();
     }
     /**
@@ -309,10 +318,16 @@ export class LoRAAdapter {
      */
     loadWeights() {
         try {
-            if (!existsSync(this.config.weightsPath)) {
-                return false;
+            // Canonical path first, then legacy `.swarm/lora-weights.json` as a
+            // read-only fallback for consumers who upgraded mid-training (#1168).
+            let sourcePath = this.config.weightsPath;
+            if (!existsSync(sourcePath)) {
+                const legacy = legacySwarmPath('lora-weights.json');
+                if (!existsSync(legacy))
+                    return false;
+                sourcePath = legacy;
             }
-            const content = readFileSync(this.config.weightsPath, 'utf-8');
+            const content = readFileSync(sourcePath, 'utf-8');
             const data = JSON.parse(content);
             if (data.version !== 1) {
                 return false;

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

@@ -6,7 +6,8 @@
  * - Gating network for soft expert selection (top-k)
  * - Online weight updates via reward signals
  * - Load balancing with auxiliary loss
- * - Weight persistence to .swarm/moe-weights.json
+ * - Weight persistence to .moflo/movector/moe-weights.json
+ *   (legacy fallback read: .swarm/moe-weights.json)
  *
  * Architecture:
  * - Input: 384-dim task embedding (from ONNX)
@@ -17,6 +18,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
+import { legacySwarmPath, runtimePath } from '../services/moflo-paths.js';
 /**
  * Expert names in order (index corresponds to expert slot)
  */
@@ -43,14 +45,15 @@ export const INPUT_DIM = 384;
  */
 export const HIDDEN_DIM = 128;
 /**
- * Default configuration
+ * Default configuration. `weightsPath` is overridden lazily in the
+ * MoERouter constructor (see #1168) so the path resolves against the
+ * consumer's project root, not the module-load cwd.
  */
 const DEFAULT_CONFIG = {
     topK: 2,
     learningRate: 0.01,
     temperature: 1.0,
     loadBalanceCoef: 0.01,
-    weightsPath: '.swarm/moe-weights.json',
     autoSaveInterval: 50,
     enableNoise: true,
     noiseStd: 0.1,
@@ -202,7 +205,15 @@ export class MoERouter {
     lastProbs = null;
     lastSelectedExperts = [];
     constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Resolve weightsPath lazily here (#1168) — the default routes through
+        // findProjectRoot at construct-time, not module-load time. Default-rescue
+        // runs *last* so an explicit `weightsPath: undefined` falls back to the
+        // canonical path instead of leaving the field undefined.
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            weightsPath: config.weightsPath ?? runtimePath('movector', 'moe-weights.json'),
+        };
         // Initialize weights
         this.W1 = xavierInit(INPUT_DIM, HIDDEN_DIM);
         this.b1 = new Float32Array(HIDDEN_DIM);
@@ -445,10 +456,15 @@ export class MoERouter {
      * Load weights from persistence file
      */
     async loadWeights(path) {
-        const weightsPath = path || this.config.weightsPath;
+        // Canonical path first, then legacy `.swarm/moe-weights.json` as a
+        // read-only fallback for consumers who upgraded mid-training (#1168).
+        let weightsPath = path || this.config.weightsPath;
         try {
             if (!existsSync(weightsPath)) {
-                return false;
+                const legacy = legacySwarmPath('moe-weights.json');
+                if (!existsSync(legacy))
+                    return false;
+                weightsPath = legacy;
             }
             const data = readFileSync(weightsPath, 'utf-8');
             const model = JSON.parse(data);

package/dist/src/cli/services/ephemeral-namespace-purge.js

@@ -105,4 +105,51 @@ export async function purgeEphemeralNamespaces(options = {}) {
         db.close();
     }
 }
+/**
+ * Hard-delete rows whose namespace matches one of
+ * {@link PURGE_ON_SESSION_START_PREFIXES} — currently `doctor-memprobe-*`
+ * and `doctor-neighbors-*`. Scoped down from {@link purgeEphemeralNamespaces}:
+ * no exact-namespace pass, no tasklist trim, no VACUUM. Returns
+ * `{ purged: 0 }` on a missing DB / missing `memory_entries` / clean state.
+ *
+ * Intended for the doctor's Memory Access functional check finally block
+ * (#1166). Only the doctor writes to these namespaces in production, so
+ * sweeping by prefix at the end of every healer run kills the
+ * `populated:ephemeral-purged` flake class — a per-key `safeDelete` that
+ * silently no-ops (row not visible at delete time, MCP transport error,
+ * `memory_delete` returning `success: true, deleted: false`) no longer
+ * leaks a row into the next assertion. The launcher's session-start
+ * purge stays in place as a defence-in-depth safety net for residue from
+ * crashed-process scenarios where the doctor never reached its finally.
+ *
+ * Errors propagate to the caller (the doctor absorbs them so a failed
+ * sweep never poisons the check return value).
+ */
+export async function purgeMemoryProbeNamespaces(options = {}) {
+    const fs = await import('fs');
+    const path = await import('path');
+    const dbPath = path.resolve(options.dbPath ?? memoryDbPath(process.cwd()));
+    if (!fs.existsSync(dbPath))
+        return { purged: 0 };
+    const prefixes = Array.from(PURGE_ON_SESSION_START_PREFIXES);
+    if (prefixes.length === 0)
+        return { purged: 0 };
+    const db = openDaemonDatabase(dbPath);
+    try {
+        const probe = db.exec(`SELECT name FROM sqlite_master WHERE type='table' AND name='memory_entries' LIMIT 1`);
+        if (!probe[0]?.values?.[0])
+            return { purged: 0 };
+        const whereClause = prefixes.map(() => 'namespace LIKE ?').join(' OR ');
+        const bindings = prefixes.map((p) => `${p}%`);
+        const countRows = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE ${whereClause}`, bindings);
+        const purgeable = Number(countRows[0]?.values?.[0]?.[0] ?? 0);
+        if (purgeable === 0)
+            return { purged: 0 };
+        db.run(`DELETE FROM memory_entries WHERE ${whereClause}`, bindings);
+        return { purged: db.getRowsModified?.() ?? 0 };
+    }
+    finally {
+        db.close();
+    }
+}
 //# sourceMappingURL=ephemeral-namespace-purge.js.map

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

@@ -21,6 +21,7 @@
  */
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { findProjectRoot } from './project-root.js';
 export const MOFLO_DIR = '.moflo';
 /** Canonical memory DB filename (post-#727). Lives at `<root>/.moflo/moflo.db`. */
 export const MEMORY_DB_FILE = 'moflo.db';
@@ -68,6 +69,25 @@ export function legacyHnswIndexPath(projectRoot) {
 export function legacyMemoryDbBakPath(projectRoot) {
     return join(projectRoot, LEGACY_SWARM_DIR, `${LEGACY_MEMORY_DB_FILE}${LEGACY_MEMORY_DB_BAK_SUFFIX}`);
 }
+/**
+ * Resolve a runtime-state path under `.moflo/<subdir>/<filename>` at the
+ * project root. Lazy by design — every call routes through `findProjectRoot()`
+ * so the path never bakes in `process.cwd()` at module-load time (#1168 bug
+ * class). Use this for any persisted runtime state the daemon, MCP server,
+ * or neural runtime writes (weights, fisher matrix, routing patterns, etc.).
+ */
+export function runtimePath(subdir, filename) {
+    return join(mofloDir(findProjectRoot()), subdir, filename);
+}
+/**
+ * Legacy `.swarm/<filename>` path at the project root. Read-only fallback for
+ * consumers who saved state under the pre-#1168 location; never written by
+ * production code (enforced by the drift-guard in
+ * `published-package-drift-guard.test.ts`).
+ */
+export function legacySwarmPath(filename) {
+    return join(findProjectRoot(), LEGACY_SWARM_DIR, filename);
+}
 /**
  * Memory-DB probe order used by every reader that does best-effort detection
  * (statusline, doctor, swarm status, hooks aggregator). Canonical first so

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

package/package.json

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