moflo 4.10.10 → 4.10.11

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-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/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/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/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.11';
 //# sourceMappingURL=version.js.map

package/package.json

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