moflo 4.10.9 → 4.10.11

package/.claude/skills/luminarium/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: luminarium
+description: |
+  Print the localhost URL for The Luminarium — moflo's daemon dashboard — for the current project.
+  Use when the user asks for "the luminarium link", "the moflo dashboard", "the daemon UI", or anything synonymous.
+  Each project gets a deterministic port in 33000–33999; the actual bound port is recorded in `.moflo/daemon.lock`.
+---
+
+# /luminarium — Project Dashboard Link
+
+Surface the URL for The Luminarium (the moflo daemon's localhost UI) for the project that this session is running in. No prompts, no confirmations — print the link and stop.
+
+## Procedure
+
+1. **Find the project root.** Walk up from `process.cwd()` looking for a `.moflo/` directory. The session's cwd is almost always the project root, so check there first.
+
+2. **Read `.moflo/daemon.lock`.** It's a JSON file written by the daemon at bind time. The dashboard port is the `port` field:
+
+   ```json
+   { "pid": 12345, "port": 33421, "startedAt": "...", ... }
+   ```
+
+   - If the file exists and `port` is a valid number → the daemon is running and bound. Use that port.
+   - If the file is missing or `port` is absent/invalid → the daemon is not running. See step 4.
+
+3. **Print the link** in a single line, with the path verbatim — Claude Code renders it as clickable:
+
+   ```
+   The Luminarium: http://localhost:<port>
+   ```
+
+   Nothing else. No banner, no follow-up question, no "what would you like to do?".
+
+4. **If the daemon isn't running** (no lock file, or unparseable), say so in one line and offer the start command — don't run it:
+
+   ```
+   The moflo daemon isn't running for this project. Start it with: npx flo daemon start
+   ```
+
+## Why read the lock, not compute the port
+
+The port is project-deterministic (sha256(projectRoot) mapped into 33000–33999), but if the deterministic port was already taken at bind time the daemon scans forward and binds an alternate. The lock file is the only source of truth for what's actually bound. Do not compute the hash yourself — read the file.
+
+## Don't
+
+- Don't fall back to any hardcoded port — there is no project-agnostic dashboard port; a literal would route to a foreign daemon on a multi-project machine. If the lock is missing, report "not running".
+- Don't compute the deterministic port and report it as the link when the lock is missing — the daemon may be down, or bound to an alternate port. Report "not running" instead.
+- Don't run `flo daemon start` automatically — the user asked for a link, not for daemon management. Leave starting to `/healer` or the user.
+- Don't open a browser. Print the URL; let the user click.
+
+## Output
+
+A single line. Examples:
+
+```
+The Luminarium: http://localhost:33421
+```
+
+```
+The moflo daemon isn't running for this project. Start it with: npx flo daemon start
+```
+
+## See Also
+
+- `/healer` — diagnoses and (with `--fix`) starts the daemon if it's not running.
+- `src/cli/services/daemon-port.ts` (and its JS twin `bin/lib/daemon-port.mjs`) — canonical port-resolution helpers; `resolveClientPort()` is what the rest of moflo uses.

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/init/executor.js

@@ -35,6 +35,7 @@ export const SKILLS_MAP = {
         'guidance',
         'healer',
         'flo-simplify',
+        'luminarium',
         'reasoningbank-intelligence',
     ],
     memory: [

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/daemon-dashboard.js

@@ -798,6 +798,14 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
     .btn-primary { background: #238636; border-color: #2ea043; color: #fff; }
     .btn-primary:hover { background: #2ea043; border-color: #3fb950; }
     .dim { color: #484f58; font-size: 0.75rem; font-style: italic; }
+    /* Loading state for tabs whose data is slow on first paint (currently
+       Claude Stats, which walks the user's transcript dir — can take 10–15s
+       on a long history). Pure-CSS spinner; no image, no framework. */
+    .loading-block { display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 14px; padding: 48px 16px; color: #8b949e; }
+    .loading-block .spinner { width: 28px; height: 28px; border: 3px solid #30363d; border-top-color: #58a6ff; border-radius: 50%; animation: lum-spin 0.85s linear infinite; }
+    .loading-block .msg { font-size: 0.9rem; color: #c9d1d9; }
+    .loading-block .hint { font-size: 0.8rem; color: #8b949e; font-style: italic; max-width: 480px; text-align: center; line-height: 1.5; }
+    @keyframes lum-spin { to { transform: rotate(360deg); } }
   </style>
 </head>
 <body>
@@ -811,7 +819,7 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
   <div id="panel-schedules" class="panel" style="display:none"><div id="schedules-active"></div><div id="schedules-events"></div></div>
   <div id="panel-executions" class="panel" style="display:none"></div>
   <div id="panel-memory" class="panel" style="display:none"></div>
-  <div id="panel-claude-stats" class="panel" style="display:none"></div>
+  <div id="panel-claude-stats" class="panel" style="display:none"><div class="loading-block" role="status" aria-label="Loading Claude Code transcripts"><div class="spinner"></div><div class="msg">Reading Claude Code transcripts…</div><div class="hint">First load can take 10–15 seconds — moflo walks every session file in this project's transcript directory. Subsequent loads in this tab are much faster.</div></div></div>
   <div id="poll-indicator" class="poll-indicator"></div>
   <script>
     // Tab navigation — plain DOM, no framework
@@ -1139,7 +1147,19 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
     };
     function renderClaudeStats(cs) {
       const el = document.getElementById('panel-claude-stats');
-      if (!cs) { el.innerHTML = '<div class="empty">Loading...</div>'; return; }
+      // cs is null on first paint AND on fetch error (Promise chain uses
+      // .catch(() => null)). Render the spinner block on both so the user
+      // sees motion during the 10–15s transcript walk and during a transient
+      // network blip — better than a static "Loading..." that looks frozen.
+      if (!cs) {
+        el.innerHTML =
+          '<div class="loading-block" role="status" aria-label="Loading Claude Code transcripts">' +
+            '<div class="spinner"></div>' +
+            '<div class="msg">Reading Claude Code transcripts…</div>' +
+            '<div class="hint">First load can take 10–15 seconds — moflo walks every session file in this project\\'s transcript directory. Subsequent loads in this tab are much faster.</div>' +
+          '</div>';
+        return;
+      }
 
       // Always-visible disclaimer banner — keeps the scope and limits in
       // view so the numbers aren't read as account-wide truth.

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

package/package.json

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