moflo 4.10.8 → 4.10.10

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/bin/hooks.mjs

@@ -36,14 +36,15 @@ const __dirname = dirname(__filename);
 // projects, so __dirname-relative paths break. findProjectRoot() works
 // everywhere and resolves identically to the TS bridge (see lib/moflo-paths.mjs).
 const projectRoot = findProjectRoot();
-const logFile = resolve(projectRoot, '.swarm/hooks.log');
+const logFile = resolve(projectRoot, '.moflo', 'logs', 'hooks.log');
+try { mkdirSync(dirname(logFile), { recursive: true }); } catch { /* best effort */ }
 const pm = createProcessManager(projectRoot);
 
 // Parse command line args
 const args = process.argv.slice(2);
 const hookType = args[0];
 
-// Simple log function - writes to .swarm/hooks.log
+// Simple log function - writes to .moflo/logs/hooks.log
 function log(level, message) {
   const timestamp = new Date().toISOString();
   const line = `[${timestamp}] [${level.toUpperCase()}] [${hookType || 'unknown'}] ${message}\n`;

package/bin/index-all.mjs

@@ -13,7 +13,7 @@
  * Spawned as a single detached background process by hooks.mjs session-start.
  */
 
-import { existsSync, appendFileSync, readFileSync } from 'fs';
+import { existsSync, appendFileSync, readFileSync, mkdirSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { spawn, spawnSync } from 'child_process';
@@ -43,7 +43,8 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // so __dirname-relative paths break. findProjectRoot() (lib/moflo-paths.mjs)
 // works in both locations and resolves identically to the TS bridge.
 const projectRoot = findProjectRoot();
-const LOG_PATH = resolve(projectRoot, '.swarm/hooks.log');
+const LOG_PATH = resolve(projectRoot, '.moflo', 'logs', 'hooks.log');
+try { mkdirSync(dirname(LOG_PATH), { recursive: true }); } catch { /* best effort */ }
 
 function log(msg) {
   const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);

package/bin/index-guidance.mjs

@@ -845,16 +845,16 @@ if (!skipEmbeddings && needsEmbeddings) {
 
   if (embeddingScript) {
     // Register the spawn with the shared ProcessManager (#886). Stdout/stderr
-    // route through `.swarm/background.log` (pm.spawn default) instead of the
-    // bespoke `.moflo/logs/embeddings.log` so the registry, dedup, and
-    // session-end drain stay consistent with every other tracked spawn.
+    // route through `.moflo/logs/background.log` (pm.spawn default) so the
+    // registry, dedup, and session-end drain stay consistent with every other
+    // tracked spawn.
     const pm = createProcessManager(projectRoot);
     const result = pm.spawn('node', [embeddingScript, '--namespace', NAMESPACE], `build-embeddings-${NAMESPACE}`);
     if (result.skipped) {
       log(`Background embedding already running (PID: ${result.pid})`);
     } else if (result.pid) {
       log(`Background embedding started (PID: ${result.pid})`);
-      log(`Log file: .swarm/background.log`);
+      log(`Log file: .moflo/logs/background.log`);
     } else {
       log('⚠️  Failed to spawn background embedding');
     }

package/bin/lib/process-manager.mjs

@@ -164,9 +164,9 @@ export function createProcessManager(root) {
         // This ensures errors from background indexers/pretrain are captured
         let stdio = 'ignore';
         try {
-          const swarmDir = resolve(projectRoot, '.swarm');
-          ensureDir(swarmDir);
-          const logPath = resolve(swarmDir, 'background.log');
+          const logsDir = resolve(projectRoot, '.moflo', 'logs');
+          ensureDir(logsDir);
+          const logPath = resolve(logsDir, 'background.log');
           const fd = openSync(logPath, 'a');
           stdio = ['ignore', fd, fd];
         } catch {

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

@@ -7,8 +7,8 @@ import { existsSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import os from 'os';
 import { findProjectDaemonPids, getDaemonLockHolder, getDaemonLockPayload, } from '../services/daemon-lock.js';
-import { resolveClientPort, LEGACY_DEFAULT_PORT, probeDaemonHealth as probeDaemonHealthIdentity, normalizeProjectRoot, } from '../services/daemon-port.js';
-import { legacyMemoryDbPath, memoryDbCandidatePaths, memoryDbPath, } from '../services/moflo-paths.js';
+import { resolveClientPort, LEGACY_DEFAULT_PORT, probeDaemonHealthWithRetry as probeDaemonHealthIdentity, normalizeProjectRoot, } from '../services/daemon-port.js';
+import { LEGACY_SWARM_DIR, memoryDbCandidatePaths, memoryDbPath, } from '../services/moflo-paths.js';
 import { probeDbIntegrity } from '../services/memory-db-integrity-repair.js';
 import { findProjectRoot } from '../services/project-root.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
@@ -253,14 +253,10 @@ export async function checkMemoryDatabase() {
         }
         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 };
+            // Legacy `.swarm/memory.db` residue is owned by the separate
+            // `checkSwarmResidue` check so we keep this check focused on the
+            // canonical DB. That check carries the auto-fix.
+            return { name: 'Memory Database', status: 'pass', message: `.moflo/moflo.db (${sizeMB} MB)` };
         }
         return {
             name: 'Memory Database',
@@ -271,6 +267,44 @@ export async function checkMemoryDatabase() {
     }
     return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
 }
+/**
+ * Catches `.swarm/` residue that survived past the canonical migration:
+ *  - `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.
+ *  - `hooks.log` / `background.log` — diagnostic logs the launcher used to
+ *    route to `.swarm/`; relocate to `.moflo/logs/`.
+ *
+ * Passes when `.swarm/` is absent OR contains nothing the migrator recognises.
+ * Otherwise warns with `fix: 'flo healer --fix -c swarm-residue'` so the auto-fix
+ * dispatcher (`fixSwarmLegacyResidue` in doctor-fixes.ts) can clean it up in
+ * one pass.
+ */
+export async function checkSwarmResidue() {
+    const root = findProjectRoot();
+    const swarmDir = join(root, LEGACY_SWARM_DIR);
+    if (!existsSync(swarmDir)) {
+        return { name: 'Swarm Residue', status: 'pass', message: 'No .swarm/ directory present' };
+    }
+    const artifacts = [
+        'memory.db',
+        'memory.db.bak',
+        'q-learning-model.json',
+        'model-router-state.json',
+        'hooks.log',
+        'background.log',
+    ];
+    const present = artifacts.filter(name => existsSync(join(swarmDir, name)));
+    if (present.length === 0) {
+        return { name: 'Swarm Residue', status: 'pass', message: '.swarm/ present but no known residue' };
+    }
+    return {
+        name: 'Swarm Residue',
+        status: 'warn',
+        message: `${present.length} legacy artifact(s) in .swarm/: ${present.join(', ')}`,
+        fix: 'flo healer --fix -c swarm-residue',
+    };
+}
 /**
  * Tier-1 corruption probe for `.moflo/moflo.db`. Runs `PRAGMA integrity_check`
  * via a raw node:sqlite readonly handle — bypasses `openBackend` because that

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

@@ -5,7 +5,7 @@
  * shell-out where possible). Falls back to running the check's `fix` string
  * if it looks like an `npx`/`npm`/`claude` command.
  */
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmdirSync, unlinkSync, writeFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { output } from '../output.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
@@ -13,6 +13,7 @@ import { atomicWriteFileSync } from '../shared/utils/atomic-file-write.js';
 import { repairHookWiring } from '../services/hook-wiring.js';
 import { getDaemonLockHolder } from '../services/daemon-lock.js';
 import { findProjectRoot } from '../services/project-root.js';
+import { legacyMemoryDbPath, legacyMemoryDbBakPath, memoryDbPath, mofloDir } from '../services/moflo-paths.js';
 import { findZombieProcesses } from './doctor-zombies.js';
 import { inspectMcpConfigs } from './doctor-checks-config.js';
 import { installClaudeCode, runCommand } from './doctor-checks-runtime.js';
@@ -94,6 +95,131 @@ async function fixGateHealthHooks() {
     }
     return driftFixed && wiringFixed;
 }
+/**
+ * Migrate `.swarm/` residue to its canonical home and remove the legacy directory.
+ *
+ * Three categories of artifact:
+ *   1. `memory.db` (+ `.bak`)               — stale once `.moflo/moflo.db` exists; delete.
+ *   2. `q-learning-model.json` / `model-router-state.json` — live RL state.
+ *      Rename into `.moflo/movector/`. If the canonical target already exists
+ *      (consumer ran moflo on the new defaults before the auto-fix), the
+ *      canonical wins and the `.swarm/` copy is unlinked.
+ *   3. `hooks.log` / `background.log`       — diagnostic logs. Relocate to
+ *      `.moflo/logs/`; append into the canonical file if it already exists
+ *      so we don't drop history. Best-effort — log loss is acceptable.
+ *
+ * Finally `rmdir .swarm/` if and only if it's empty. Anything we didn't
+ * recognise is left in place rather than silently deleted.
+ *
+ * Cross-platform: uses `fs.rename`/`rmdir` (Node primitives), forward-slash-free
+ * joins via `path.join`. Works on Windows + POSIX.
+ *
+ * Returns true if the directory was fully retired OR if there was nothing to
+ * migrate; false if any relocation throws or `.swarm/` survives with unknown
+ * contents.
+ */
+async function fixSwarmLegacyResidue() {
+    const root = findProjectRoot();
+    const swarmDir = join(root, '.swarm');
+    if (!existsSync(swarmDir))
+        return true;
+    const canonicalDb = memoryDbPath(root);
+    const moflo = mofloDir(root);
+    const movectorDir = join(moflo, 'movector');
+    const logsDir = join(moflo, 'logs');
+    let allMigrated = true;
+    // (1) memory.db + .bak — both are migration artifacts of the launcher's
+    // copy-verify-rename step; if the canonical isn't yet in place neither
+    // source is safe to delete. The launcher creates the `.bak` only AFTER
+    // canonical exists, so this guard is conservative but correct.
+    const legacyDbPaths = [
+        ['memory.db', legacyMemoryDbPath(root)],
+        ['memory.db.bak', legacyMemoryDbBakPath(root)],
+    ];
+    for (const [name, src] of legacyDbPaths) {
+        if (!existsSync(src))
+            continue;
+        if (!existsSync(canonicalDb)) {
+            output.writeln(output.warning(`  Skipping ${name}: .moflo/moflo.db absent — run \`flo memory init\` first.`));
+            allMigrated = false;
+            continue;
+        }
+        try {
+            unlinkSync(src);
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Failed to delete ${name}: ${errorDetail(e)}`));
+            allMigrated = false;
+        }
+    }
+    // (2) router state JSONs — rename into .moflo/movector/.
+    const stateFiles = [
+        { name: 'q-learning-model.json', dest: movectorDir },
+        { name: 'model-router-state.json', dest: movectorDir },
+    ];
+    for (const { name, dest } of stateFiles) {
+        const src = join(swarmDir, name);
+        if (!existsSync(src))
+            continue;
+        const target = join(dest, name);
+        try {
+            mkdirSync(dest, { recursive: true });
+            if (existsSync(target)) {
+                // Canonical already populated by a fresh save on the new defaults.
+                // Keep the canonical, drop the legacy copy.
+                unlinkSync(src);
+            }
+            else {
+                renameSync(src, target);
+            }
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Failed to relocate ${name}: ${errorDetail(e)}`));
+            allMigrated = false;
+        }
+    }
+    // (3) logs — best-effort move. Append into canonical if it already exists
+    // (don't drop history). Hook + background logs are bounded to kilobytes in
+    // practice so the read-into-memory cost is acceptable.
+    const logFiles = ['hooks.log', 'background.log'];
+    for (const name of logFiles) {
+        const src = join(swarmDir, name);
+        if (!existsSync(src))
+            continue;
+        const target = join(logsDir, name);
+        try {
+            mkdirSync(logsDir, { recursive: true });
+            if (existsSync(target)) {
+                appendFileSync(target, readFileSync(src));
+                unlinkSync(src);
+            }
+            else {
+                renameSync(src, target);
+            }
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Failed to relocate ${name}: ${errorDetail(e)}`));
+            allMigrated = false;
+        }
+    }
+    // (4) rmdir .swarm/ if it's empty. Anything left is unrecognised — leave it
+    // for the user to inspect rather than silently delete.
+    try {
+        const remaining = readdirSync(swarmDir);
+        if (remaining.length === 0) {
+            rmdirSync(swarmDir);
+        }
+        else {
+            output.writeln(output.dim(`  .swarm/ kept (${remaining.length} unrecognised entr${remaining.length === 1 ? 'y' : 'ies'}): ${remaining.join(', ')}`));
+            allMigrated = false;
+        }
+    }
+    catch (e) {
+        output.writeln(output.warning(`  Failed to remove .swarm/: ${errorDetail(e)}`));
+        allMigrated = false;
+    }
+    return allMigrated;
+}
 /**
  * Execute the fix for a failed/warned health check.
  * Returns true if the fix succeeded (re-check should pass).
@@ -440,6 +566,12 @@ export async function autoFixCheck(check) {
                 return false;
             }
         },
+        // Migrate `.swarm/` residue (legacy memory.db, RL state JSONs, hook/bg logs)
+        // into their canonical `.moflo/` homes and rmdir the directory once empty.
+        // See `fixSwarmLegacyResidue` for the per-artifact policy.
+        'Swarm Residue': async () => {
+            return fixSwarmLegacyResidue();
+        },
         'Status Line': async () => {
             const settingsPath = join(process.cwd(), '.claude', 'settings.json');
             if (!existsSync(settingsPath))

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

@@ -12,7 +12,7 @@ import { checkWritersAudit } from './doctor-checks-writers-audit.js';
 import { checkSwarmFunctional, checkHiveMindFunctional, } from './doctor-checks-swarm.js';
 import { checkMemoryAccessFunctional } from './doctor-checks-memory-access.js';
 import { checkBuildTools, checkClaudeCode, checkDiskSpace, checkGit, checkGitRepo, checkNodeVersion, checkNpmVersion, } from './doctor-checks-runtime.js';
-import { checkConfigFile, checkDaemonIdentity, checkDaemonOrphan, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMemoryDbIntegrity, checkMofloYamlCompliance, checkStatusLine, checkTestDirs, } from './doctor-checks-config.js';
+import { checkConfigFile, checkDaemonIdentity, checkDaemonOrphan, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMemoryDbIntegrity, checkMofloYamlCompliance, checkStatusLine, checkSwarmResidue, checkTestDirs, } from './doctor-checks-config.js';
 import { checkSpellEngine, checkSandboxTier } from './doctor-checks-platform.js';
 import { checkEmbeddings, checkSemanticQuality, } from './doctor-checks-memory.js';
 import { checkIntelligence } from './doctor-checks-intelligence.js';
@@ -42,6 +42,10 @@ export const allChecks = [
     checkDaemonWriteRouting,
     checkWritersAudit,
     checkMemoryDatabase,
+    // Surfaces leftover `.swarm/` artifacts (memory.db, router state, logs) so
+    // the auto-fix can relocate or delete them. Independent of the canonical
+    // DB checks — runs cheap (statSync only).
+    checkSwarmResidue,
     // Owns the corruption signal so downstream checks (Embeddings, Semantic
     // Quality, Memory Access Functional) don't surface it as the synthetic
     // "Check" failure (doctor.ts:214). MUST run after checkMemoryDatabase
@@ -107,6 +111,8 @@ export const componentMap = {
     'writers-audit': checkWritersAudit,
     'writers': checkWritersAudit,
     'memory': checkMemoryDatabase,
+    'swarm-residue': checkSwarmResidue,
+    'residue': checkSwarmResidue,
     'memory-db-integrity': checkMemoryDbIntegrity,
     'integrity': checkMemoryDbIntegrity,
     'memory-integrity': checkMemoryDbIntegrity,

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/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

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

@@ -214,4 +214,39 @@ export function probeDaemonHealth(port, timeoutMs) {
         req.on('timeout', () => { req.destroy(); finish({ kind: 'unreachable' }); });
     });
 }
+/** Retry backoff schedule for HTTP liveness probes (#1163 — Windows CI race). */
+const PROBE_RETRY_BACKOFF_MS = [50, 200, 800];
+/**
+ * {@link probeDaemonHealth} with retry on transient `unreachable` results.
+ *
+ * The bare one-shot probe was tripping in CI when a daemon was mid-boot on
+ * Windows: the lockfile said v4.10.8 was alive but the HTTP server hadn't
+ * accepted /api/health yet, and the doctor check raised "unreachable" inside
+ * the 1500ms window. This wrapper retries 3× at 50/200/800 ms — total
+ * worst-case ~1s extra — and only on `unreachable`. `identity` and `legacy`
+ * are terminal: a daemon answering with a different project root or 404 is
+ * a real signal, not a race.
+ *
+ * Mirrors the retry pattern from `bin/lib/file-sync.mjs:syncWithRetry`
+ * (`feedback_transient_retry_circuit_breaker` — every transient-error op
+ * uses 50/200/800ms backoff).
+ *
+ * Worst-case elapsed = (PROBE_RETRY_BACKOFF_MS.length + 1) × timeoutMs
+ * + sum(PROBE_RETRY_BACKOFF_MS). For doctor's 1500ms timeout that's
+ * 4 × 1500 + 1050 ≈ 7s, fully off the hot path; callers picking a tighter
+ * timeout should account for the 4× multiplier.
+ */
+export async function probeDaemonHealthWithRetry(port, timeoutMs) {
+    let last = { kind: 'unreachable' };
+    const maxAttempts = PROBE_RETRY_BACKOFF_MS.length + 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (attempt > 0) {
+            await new Promise((resolve) => setTimeout(resolve, PROBE_RETRY_BACKOFF_MS[attempt - 1]));
+        }
+        last = await probeDaemonHealth(port, timeoutMs);
+        if (last.kind !== 'unreachable')
+            return last;
+    }
+    return last;
+}
 //# sourceMappingURL=daemon-port.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.8';
+export const VERSION = '4.10.10';
 //# sourceMappingURL=version.js.map

package/package.json

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