moflo 4.9.21 → 4.9.23

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

@@ -1,8 +1,14 @@
 /**
- * Daemon Dashboard — Lightweight localhost HTTP server
+ * The Arcane Console — Lightweight localhost HTTP server
  *
- * Serves a read-only VanJS dashboard for daemon status, spell logs,
- * and memory stats. Binds to 127.0.0.1 only (no auth needed).
+ * Serves the moflo Arcane Console (read-only daemon view) for status,
+ * scheduled spells, executions, and memory stats. Binds to 127.0.0.1
+ * only (no auth needed).
+ *
+ * Internal/code identifiers retain the term "dashboard" (CLI flags
+ * `--dashboard-port` / `--no-dashboard`, internal port constant) for
+ * stability with existing consumer scripts; only user-facing surface
+ * is rebranded.
  *
  * @module daemon-dashboard
  */
@@ -78,10 +84,17 @@ function tryParseSafe(s) {
 }
 function handleStatus(daemon) {
     const status = daemon.getStatus();
+    // Index config rows by worker type so the row renderer can show a
+    // "disabled" badge instead of "Last run: never" for default-off workers
+    // (audit, predict, document — see #968 user feedback).
+    const configByType = new Map();
+    for (const w of status.config.workers)
+        configByType.set(w.type, { enabled: w.enabled });
     const workers = [];
     for (const [type, state] of status.workers) {
         workers.push({
             type,
+            enabled: configByType.get(type)?.enabled ?? true,
             isRunning: state.isRunning,
             lastRun: state.lastRun?.toISOString() ?? null,
             nextRun: state.nextRun?.toISOString() ?? null,
@@ -330,6 +343,9 @@ async function handleRequest(req, res, daemon, opts) {
         else if (url === '/api/schedules') {
             sendJson(res, 200, await handleSchedules(daemon, opts));
         }
+        else if (url === '/api/schedules/events') {
+            handleSchedulesEventStream(req, res, daemon);
+        }
         else if (url === '/api/spells') {
             sendJson(res, 200, await handleSpells(opts.memory));
         }
@@ -400,6 +416,71 @@ function getSchedulerErrorCode(err) {
     }
     return null;
 }
+/** Heartbeat interval for the schedule-event SSE stream (keeps proxies + idle clients alive). */
+const SSE_HEARTBEAT_MS = 25_000;
+/**
+ * Stream `schedule:*` events to the client via Server-Sent Events.
+ *
+ * Subscribes to `scheduler.on(listener)` and forwards each event as an SSE
+ * frame (`event: <type>\ndata: <JSON>\n\n`). Sends an initial `ready` frame
+ * so the client can distinguish "connected, waiting" from "scheduler down",
+ * plus a comment heartbeat every 25s. Cleans up on client disconnect.
+ *
+ * Returns 503 when the scheduler is not attached so the client can fall back
+ * to polling. Reuses duck-typing via `daemon.getScheduler()` — no new types
+ * exported from this module.
+ */
+function handleSchedulesEventStream(req, res, daemon) {
+    const scheduler = daemon.getScheduler();
+    if (!scheduler) {
+        sendJson(res, 503, { error: 'Scheduler not attached' });
+        return;
+    }
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        'Connection': 'keep-alive',
+        'X-Accel-Buffering': 'no',
+    });
+    // Initial frame so the client knows the channel is live even before
+    // the first scheduler event arrives (which may be minutes away).
+    res.write(`event: ready\ndata: ${JSON.stringify({ timestamp: Date.now() })}\n\n`);
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        clearInterval(heartbeat);
+        unsubscribe();
+        try {
+            res.end();
+        }
+        catch { /* already ended */ }
+    };
+    const unsubscribe = scheduler.on((event) => {
+        try {
+            res.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+        }
+        catch {
+            // Half-open socket: the request may never emit 'close'. Defer cleanup
+            // to the next microtask so we don't splice the listeners array we are
+            // currently being iterated from inside.
+            queueMicrotask(cleanup);
+        }
+    });
+    const heartbeat = setInterval(() => {
+        try {
+            res.write(`: ping ${Date.now()}\n\n`);
+        }
+        catch {
+            queueMicrotask(cleanup);
+        }
+    }, SSE_HEARTBEAT_MS);
+    if (typeof heartbeat.unref === 'function')
+        heartbeat.unref();
+    req.on('close', cleanup);
+    req.on('error', cleanup);
+}
 // ============================================================================
 // Server lifecycle
 // ============================================================================
@@ -479,11 +560,28 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>MoFlo Dashboard</title>
+  <title>The Arcane Console</title>
+  <meta name="description" content="The Arcane Console — moflo daemon, scheduled spells, and live event stream">
+  <meta property="og:title" content="The Arcane Console">
+  <meta property="og:description" content="The Arcane Console — moflo daemon, scheduled spells, and live event stream">
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Cinzel+Decorative:wght@700;900&display=swap" rel="stylesheet">
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
     body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0d1117; color: #c9d1d9; padding: 20px; }
-    h1 { color: #58a6ff; margin-bottom: 4px; font-size: 1.5rem; }
+    /* Wizardy chain — Cinzel Decorative is the Google Font; the rest are
+       the most likely system serifs across macOS / Windows / Linux so the
+       title still reads "arcane" if the user is offline or behind a font-CDN
+       block (Georgia ships everywhere; serif is the universal fallback). */
+    h1 { font-family: 'Cinzel Decorative', 'Cinzel', 'Trajan Pro', 'Palatino Linotype', 'Book Antiqua', Georgia, serif; font-weight: 900; letter-spacing: 0.04em; margin-bottom: 4px; font-size: 1.85rem; }
+    /* Per-word arcane palette. Hues chosen at L≈45-50%, S≈60-70% so they read on
+       both #0d1117 (dark) and #ffffff (light) — WCAG-AA at large-text size on
+       both. Each word's shadow matches its own hue so the glow doesn't bleed
+       a single color across all three. */
+    h1 .w-the     { color: #8b5cf6; text-shadow: 0 0 18px rgba(139, 92, 246, 0.18); }
+    h1 .w-arcane  { color: #2563eb; text-shadow: 0 0 18px rgba(37, 99, 235, 0.18); }
+    h1 .w-console { color: #059669; text-shadow: 0 0 18px rgba(5, 150, 105, 0.18); }
     h2 { color: #8b949e; font-size: 1.1rem; margin: 16px 0 12px; border-bottom: 1px solid #21262d; padding-bottom: 6px; }
     .header { display: flex; align-items: baseline; gap: 12px; margin-bottom: 16px; }
     .subtitle { color: #8b949e; font-size: 0.85rem; }
@@ -531,13 +629,13 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
 </head>
 <body>
   <div class="header">
-    <h1>MoFlo Dashboard</h1>
-    <span class="subtitle">read-only &bull; localhost</span>
+    <h1><span class="w-the">The</span> <span class="w-arcane">Arcane</span> <span class="w-console">Console</span></h1>
+    <span class="subtitle">moflo daemon &bull; localhost</span>
   </div>
   <div id="status-bar" class="status-bar"><div class="empty">Loading...</div></div>
   <div class="nav" id="nav"></div>
   <div id="panel-workers" class="panel"></div>
-  <div id="panel-schedules" class="panel" style="display:none"></div>
+  <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="poll-indicator" class="poll-indicator"></div>
@@ -613,15 +711,25 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
 
     function renderWorkers(s) {
       if (!s) return;
-      const rows = s.workers.map(w =>
-        '<tr><td>' + esc(w.type) + '</td>' +
-        '<td>' + (w.isRunning ? badge('running','yellow') : badge('idle','gray')) + '</td>' +
-        '<td>' + w.runCount + '</td>' +
-        '<td>' + pct(w.successCount, w.failureCount) + '</td>' +
-        '<td>' + fmtDuration(w.averageDurationMs) + '</td>' +
-        '<td>' + fmtTimeAgo(w.lastRun) + '</td>' +
-        '<td>' + (w.nextRun ? fmtTime(w.nextRun) : '-') + '</td></tr>'
-      ).join('');
+      // Disabled workers show a clear "disabled" badge and dim "—" cells
+      // instead of "idle"/"never" — those terms imply the worker is healthy
+      // but quiet, which misled users into thinking audit/predict/document
+      // were broken (#968).
+      const rows = s.workers.map(w => {
+        const statusBadge = w.enabled === false
+          ? badge('disabled', 'gray')
+          : (w.isRunning ? badge('running', 'yellow') : badge('idle', 'gray'));
+        const dim = '<span class="dim">—</span>';
+        const lastRun = w.enabled === false && !w.lastRun ? dim : fmtTimeAgo(w.lastRun);
+        const nextRun = w.enabled === false ? dim : (w.nextRun ? fmtTime(w.nextRun) : '-');
+        return '<tr><td>' + esc(w.type) + '</td>' +
+          '<td>' + statusBadge + '</td>' +
+          '<td>' + w.runCount + '</td>' +
+          '<td>' + pct(w.successCount, w.failureCount) + '</td>' +
+          '<td>' + fmtDuration(w.averageDurationMs) + '</td>' +
+          '<td>' + lastRun + '</td>' +
+          '<td>' + nextRun + '</td></tr>';
+      }).join('');
       document.getElementById('panel-workers').innerHTML =
         '<h2>Worker Status</h2>' +
         '<table><thead><tr><th>Worker</th><th>Status</th><th>Runs</th><th>Success</th><th>Avg</th><th>Last Run</th><th>Next Run</th></tr></thead>' +
@@ -643,7 +751,7 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
     window.__schedAction = scheduleAction;
 
     function renderSchedules(sc) {
-      const el = document.getElementById('panel-schedules');
+      const el = document.getElementById('schedules-active');
       if (!sc) { el.innerHTML = '<div class="empty">Loading...</div>'; return; }
 
       if (sc.disabledInConfig) {
@@ -684,6 +792,67 @@ const DASHBOARD_HTML = `<!DOCTYPE html>
       if (sc.history && sc.history.length) renderSchedulesHistory(el, sc.history, /*append*/ true);
     }
 
+    // Live events tail (Server-Sent Events from /api/schedules/events).
+    // The events div lives outside renderSchedules' write target so polled
+    // re-renders of the schedules panel don't touch it; pushSchedEvent is
+    // the only writer. Single source of truth for known event types + their
+    // badge color — adding a new schedule:* type means one entry here.
+    const SCHED_EVENT_BADGES = {
+      'schedule:due': 'gray',
+      'schedule:started': 'gray',
+      'schedule:completed': 'green',
+      'schedule:failed': 'red',
+      'schedule:skipped': 'yellow',
+      'schedule:disabled': 'yellow',
+      'schedule:catchup': 'yellow',
+    };
+    const SCHED_EVENT_TYPES = Object.keys(SCHED_EVENT_BADGES);
+    const SCHED_EVENTS_MAX = 50;
+    const schedEvents = [];
+
+    function renderEventsTail() {
+      const el = document.getElementById('schedules-events');
+      if (!el) return;
+      if (schedEvents.length === 0) {
+        el.innerHTML = '<h2>Live Events</h2><div class="empty">Waiting for scheduler activity…</div>';
+        return;
+      }
+      const rows = schedEvents.map(e => {
+        const t = e.type || '?';
+        const short = String(t).replace('schedule:', '');
+        return '<tr><td>' + new Date(e.timestamp || Date.now()).toLocaleTimeString() + '</td>' +
+          '<td>' + badge(short, SCHED_EVENT_BADGES[t] || 'gray') + '</td>' +
+          '<td>' + esc(e.spellName || '-') + '</td>' +
+          '<td>' + esc(e.message || '') + '</td></tr>';
+      }).join('');
+      el.innerHTML = '<h2>Live Events</h2>' +
+        '<table><thead><tr><th>Time</th><th>Event</th><th>Spell</th><th>Detail</th></tr></thead>' +
+        '<tbody>' + rows + '</tbody></table>';
+    }
+    function pushSchedEvent(ev) {
+      schedEvents.unshift(ev);
+      if (schedEvents.length > SCHED_EVENTS_MAX) schedEvents.length = SCHED_EVENTS_MAX;
+      renderEventsTail();
+    }
+    renderEventsTail(); // Initial empty-state paint.
+
+    // Subscribe via EventSource. Browser handles auto-reconnect with backoff.
+    let evtSource = null;
+    function connectEventStream() {
+      try { if (evtSource) evtSource.close(); } catch (e) { /* ignore */ }
+      try {
+        evtSource = new EventSource('/api/schedules/events');
+        SCHED_EVENT_TYPES.forEach(t => {
+          evtSource.addEventListener(t, ev => {
+            try { pushSchedEvent(JSON.parse(ev.data)); } catch (e) { /* malformed frame */ }
+          });
+        });
+      } catch (e) {
+        console.warn('Event stream unavailable:', e);
+      }
+    }
+    connectEventStream();
+
     function renderSchedulesHistory(el, history, append) {
       const rows = history.map(h => {
         const statusBadge = h.success === true ? badge('pass','green')

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

@@ -1,29 +1,36 @@
 /**
  * Daemon Readiness Check for Scheduled Spells
  *
- * Lazy three-state flow: only triggered when creating schedules.
- * 1. Is daemon running? If not, prompt to start it.
- * 2. Is daemon installed as OS service? If not, prompt to install.
- * Always creates the schedule regardless — the daemon picks it up on next start.
+ * Confirms the daemon is currently running so a freshly-created schedule
+ * actually fires. Prompts the user to start it interactively, or warns
+ * non-interactively. Always returns regardless of state — the caller still
+ * writes the schedule, and the daemon picks it up on next start.
+ *
+ * OS-autostart install/uninstall is no longer handled here — see
+ * `daemon-autostart-lifecycle.ts`. That side effect is now driven by the
+ * count of enabled schedules, not a per-create prompt.
  */
 import { join, resolve } from 'path';
 import { mkdirSync, openSync, closeSync } from 'fs';
 import { spawn } from 'child_process';
 import { getDaemonLockHolder } from './daemon-lock.js';
-import { isDaemonInstalled, installDaemonService } from './daemon-service.js';
+import { isDaemonInstalled } from './daemon-service.js';
 import { locateMofloCliBin } from './moflo-require.js';
 import { registerBackgroundPid } from './process-registry.js';
 /**
  * Ensure the daemon is ready for scheduled spell execution.
  *
- * Checks daemon state and prompts the user to start/install as needed.
- * Always returns — never throws. The caller should create the schedule
- * regardless of the result, since the daemon can pick it up later.
+ * Checks daemon state and prompts the user to start it as needed. Always
+ * returns — never throws. The caller should create the schedule regardless
+ * of the result, since the daemon can pick it up later. OS-autostart is
+ * reconciled separately by the create/cancel paths via
+ * `reconcileDaemonAutostart`.
  */
 export async function ensureDaemonForScheduling(options) {
     const resolvedRoot = resolve(options.projectRoot);
     const promptFn = options.promptConfirm ?? defaultPromptConfirm;
     const startFn = options.startDaemon ?? defaultStartDaemon;
+    const installedFn = options.isDaemonInstalledFn ?? isDaemonInstalled;
     const result = {
         daemonRunning: false,
         daemonInstalled: false,
@@ -50,29 +57,10 @@ export async function ensureDaemonForScheduling(options) {
             result.warnings.push('Daemon is not running. Start it with: moflo daemon start');
         }
     }
-    // Step 2: Check if daemon is installed as OS autostart service. This
-    // check is independent of the running state — a user with the daemon
-    // currently down still needs the autostart warning so their new schedule
-    // survives the next reboot.
-    result.daemonInstalled = isDaemonInstalled(resolvedRoot);
-    if (!result.daemonInstalled) {
-        if (options.interactive && result.daemonRunning) {
-            const shouldInstall = await promptFn('Register the daemon as a login service so schedules survive reboots?');
-            if (shouldInstall) {
-                const installResult = installDaemonService(resolvedRoot);
-                result.daemonInstalled = installResult.success;
-                if (!installResult.success) {
-                    result.warnings.push(`Failed to install daemon service: ${installResult.message}`);
-                }
-            }
-            else {
-                result.warnings.push("Daemon is not set to autostart. Run 'moflo daemon install' so this schedule survives reboot.");
-            }
-        }
-        else {
-            result.warnings.push("Daemon is not set to autostart. Run 'moflo daemon install' so this schedule survives reboot.");
-        }
-    }
+    // Surface OS install state purely informationally — no prompts. The
+    // create/cancel commands reconcile install/uninstall via
+    // reconcileDaemonAutostart, driven by the enabled-schedule count.
+    result.daemonInstalled = installedFn(resolvedRoot);
     return result;
 }
 async function defaultPromptConfirm(message) {

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

@@ -1,49 +1,53 @@
 /**
- * Idempotent ephemeral-namespace purge for moflo's memory DB (`.moflo/moflo.db`).
+ * Idempotent session-start memory cleanup for moflo's memory DB
+ * (`.moflo/moflo.db`).
  *
- * Story #729 retired four namespaces from the persistent memory layer because
- * they store internal moflo run-tracking — not user knowledge — and embedding
- * them polluted the search index:
+ * Two passes run in a single sql.js open:
  *
- *  - `hive-mind`        (MCP broadcast traffic)
- *  - `tasklist`         (spell run records)
- *  - `epic-state`       (epic progress tracking)
- *  - `test-bridge-fix`  (single-row leftover from a one-off test)
+ * 1. **Hard-purge** namespaces in {@link PURGE_ON_SESSION_START_NAMESPACES} —
+ *    `hive-mind`, `epic-state`, `test-bridge-fix`. These store internal
+ *    run-tracking that does not need to survive a session restart. (#729)
  *
- * This service hard-deletes any rows in those namespaces left over from prior
- * moflo versions, then VACUUMs to reclaim disk. Future writes to these
- * namespaces still land in the DB — but skip embedding generation entirely
- * (see {@link EPHEMERAL_NAMESPACES} in `memory/bridge-embedder.ts`).
+ * 2. **Retention trim** the `tasklist` namespace down to the most recent
+ *    {@link TASKLIST_RETENTION_CAP} rows. `tasklist` is the dashboard's
+ *    "Flo Runs" tab data source (`daemon-dashboard.ts handleSpells`); the
+ *    pre-#968 contract hard-purged it on every session start, leaving the tab
+ *    permanently empty. Trim instead so users see recent history without
+ *    unbounded growth.
+ *
+ * Both passes share the file open + final VACUUM + atomic write, so disk I/O
+ * is the same as before. Writes back to disk only when something changed.
  *
  * Lives in `services/` so it has no dependency on the CLI command machinery.
- * That lets `bin/session-start-launcher.mjs` dynamic-import it and run the
- * purge in foreground BEFORE long-lived sql.js consumers (MCP server, daemon)
- * open the DB — sql.js dumps the whole snapshot on every flush and would
+ * That lets `bin/session-start-launcher.mjs` dynamic-import it and run in
+ * foreground BEFORE long-lived sql.js consumers (MCP server, daemon) open
+ * the DB — sql.js dumps the whole snapshot on every flush and would
  * otherwise clobber our cleanup (see #727's clobber-hazard analysis).
  *
  * @module cli/services/ephemeral-namespace-purge
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { EPHEMERAL_NAMESPACES } from '../memory/bridge-embedder.js';
+import { PURGE_ON_SESSION_START_NAMESPACES, TASKLIST_RETENTION_CAP, } from '../memory/bridge-embedder.js';
 import { mofloImport } from './moflo-require.js';
 import { atomicWriteFileSync } from './atomic-file-write.js';
 import { memoryDbPath } from './moflo-paths.js';
 /**
- * Hard-delete every row whose namespace is in {@link EPHEMERAL_NAMESPACES}
- * and VACUUM. Returns `{ purged: 0 }` on the happy path: no DB, sql.js
- * unavailable, schema lacks `memory_entries`, or no ephemeral rows present.
- * Errors propagate to the caller (the launcher absorbs them so a failed
- * purge never blocks session start).
+ * Hard-delete rows in {@link PURGE_ON_SESSION_START_NAMESPACES} and trim the
+ * `tasklist` namespace to its retention cap, then VACUUM. Returns
+ * `{ purged: 0, trimmed: 0 }` on the happy path: no DB, sql.js unavailable,
+ * schema lacks `memory_entries`, or nothing to clean. Errors propagate to
+ * the caller (the launcher absorbs them so a failed purge never blocks
+ * session start).
  */
 export async function purgeEphemeralNamespaces(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 };
+        return { purged: 0, trimmed: 0 };
     const initSqlJs = (await mofloImport('sql.js'))?.default;
     if (!initSqlJs)
-        return { purged: 0 };
+        return { purged: 0, trimmed: 0 };
     const SQL = await initSqlJs();
     const buffer = fs.readFileSync(dbPath);
     const db = new SQL.Database(buffer);
@@ -52,21 +56,45 @@ export async function purgeEphemeralNamespaces(options = {}) {
         // a no-op so we don't VACUUM unrelated SQLite files.
         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 namespaces = Array.from(EPHEMERAL_NAMESPACES);
+            return { purged: 0, trimmed: 0 };
+        // Single COUNT pass to gate both DELETEs — a clean DB is the steady
+        // state and we don't want two no-op DELETEs (with their query-planner
+        // overhead) on every session start.
+        const namespaces = Array.from(PURGE_ON_SESSION_START_NAMESPACES);
+        const cap = options.tasklistRetentionCap ?? TASKLIST_RETENTION_CAP;
         const placeholders = namespaces.map(() => '?').join(', ');
-        // Single-scan delete + rowsModified: skips a redundant COUNT pass on dirty
-        // DBs and avoids the prepare/bind/step/free overhead on clean ones. VACUUM
-        // (and the disk write) only run when something was actually deleted.
-        db.run(`DELETE FROM memory_entries WHERE namespace IN (${placeholders})`, namespaces);
-        const purged = db.getRowsModified?.() ?? 0;
-        if (purged === 0)
-            return { purged: 0 };
+        const countRows = db.exec(`SELECT
+         (SELECT COUNT(*) FROM memory_entries WHERE namespace IN (${placeholders})) AS purgeable,
+         (SELECT COUNT(*) FROM memory_entries WHERE namespace = 'tasklist') AS tasklistTotal`, namespaces);
+        const counts = countRows[0]?.values?.[0] ?? [0, 0];
+        const purgeable = Number(counts[0] ?? 0);
+        const tasklistTotal = Number(counts[1] ?? 0);
+        let purged = 0;
+        if (purgeable > 0) {
+            db.run(`DELETE FROM memory_entries WHERE namespace IN (${placeholders})`, namespaces);
+            purged = db.getRowsModified?.() ?? 0;
+        }
+        let trimmed = 0;
+        if (tasklistTotal > cap) {
+            // Keep the newest `cap` rows by created_at, falling back to `id DESC`
+            // for legacy rows that predate the created_at-not-null schema (#728-era).
+            db.run(`DELETE FROM memory_entries
+         WHERE namespace = 'tasklist'
+           AND id NOT IN (
+             SELECT id FROM memory_entries
+             WHERE namespace = 'tasklist'
+             ORDER BY created_at DESC, id DESC
+             LIMIT ?
+           )`, [cap]);
+            trimmed = db.getRowsModified?.() ?? 0;
+        }
+        if (purged === 0 && trimmed === 0)
+            return { purged: 0, trimmed: 0 };
         // VACUUM has to run outside any open transaction; sql.js auto-commits
         // each `db.run`, so this is safe to chain.
         db.run('VACUUM');
         atomicWriteFileSync(dbPath, db.export());
-        return { purged };
+        return { purged, trimmed };
     }
     finally {
         db.close();

package/dist/src/cli/services/headless-worker-executor.js

@@ -2,21 +2,14 @@
  * Headless Worker Executor
  * Enables workers to invoke Claude Code in headless mode with configurable sandbox profiles.
  *
- * ADR-020: Headless Worker Integration Architecture
+ * ADR-020: Headless Worker Integration Architecture (#970 dropped the
+ * `audit`/`document`/`predict` workers — those entries from the original
+ * ADR are superseded; the rest still applies).
  * - Integrates with CLAUDE_CODE_HEADLESS and CLAUDE_CODE_SANDBOX_MODE environment variables
  * - Provides process pool for concurrent execution
  * - Builds context from file glob patterns
  * - Supports prompt templates and output parsing
  * - Implements timeout and graceful error handling
- *
- * Key Features:
- * - Process pool with configurable maxConcurrent
- * - Context building from file glob patterns with caching
- * - Prompt template system with context injection
- * - Output parsing (text, json, markdown)
- * - Timeout handling with graceful termination
- * - Execution logging for debugging
- * - Event emission for monitoring
  */
 import { spawn, execSync } from 'child_process';
 import { EventEmitter } from 'events';
@@ -27,17 +20,14 @@ import { errorDetail } from '../shared/utils/error-detail.js';
 // Constants
 // ============================================
 /**
- * Array of headless worker types for runtime checking
+ * Array of headless worker types for runtime checking.
  */
 export const HEADLESS_WORKER_TYPES = [
-    'audit',
     'optimize',
     'testgaps',
-    'document',
     'ultralearn',
     'refactor',
     'deepdive',
-    'predict',
 ];
 /**
  * Array of local worker types
@@ -57,37 +47,11 @@ const MODEL_IDS = {
     haiku: 'claude-haiku-4-5-20251001',
 };
 /**
- * Default headless worker configurations based on ADR-020
+ * Default headless worker configurations based on ADR-020 (the
+ * `audit`/`document`/`predict` entries from the original ADR were dropped
+ * in #970 — see worker-daemon.ts header for rationale).
  */
 export const HEADLESS_WORKER_CONFIGS = {
-    audit: {
-        type: 'audit',
-        mode: 'headless',
-        intervalMs: 30 * 60 * 1000,
-        priority: 'critical',
-        description: 'AI-powered security analysis',
-        enabled: true,
-        headless: {
-            promptTemplate: `Analyze this codebase for security vulnerabilities:
-- Check for hardcoded secrets (API keys, passwords)
-- Identify SQL injection risks
-- Find XSS vulnerabilities
-- Check for insecure dependencies
-- Identify authentication/authorization issues
-
-Provide a JSON report with:
-{
-  "vulnerabilities": [{ "severity": "high|medium|low", "file": "...", "line": N, "description": "..." }],
-  "riskScore": 0-100,
-  "recommendations": ["..."]
-}`,
-            sandbox: 'strict',
-            model: 'haiku',
-            outputFormat: 'json',
-            contextPatterns: ['**/*.ts', '**/*.js', '**/.env*', '**/package.json'],
-            timeoutMs: 5 * 60 * 1000,
-        },
-    },
     optimize: {
         type: 'optimize',
         mode: 'headless',
@@ -134,29 +98,6 @@ For each gap, provide a test skeleton.`,
             timeoutMs: 10 * 60 * 1000,
         },
     },
-    document: {
-        type: 'document',
-        mode: 'headless',
-        intervalMs: 120 * 60 * 1000,
-        priority: 'low',
-        description: 'AI documentation generation',
-        enabled: false,
-        headless: {
-            promptTemplate: `Generate documentation for undocumented code:
-- Add JSDoc comments to functions
-- Create README sections for modules
-- Document API endpoints
-- Add inline comments for complex logic
-- Generate usage examples
-
-Focus on public APIs and exported functions.`,
-            sandbox: 'permissive',
-            model: 'haiku',
-            outputFormat: 'markdown',
-            contextPatterns: ['src/**/*.ts'],
-            timeoutMs: 10 * 60 * 1000,
-        },
-    },
     ultralearn: {
         type: 'ultralearn',
         mode: 'headless',
@@ -232,34 +173,6 @@ Provide comprehensive report.`,
             timeoutMs: 15 * 60 * 1000,
         },
     },
-    predict: {
-        type: 'predict',
-        mode: 'headless',
-        intervalMs: 10 * 60 * 1000,
-        priority: 'low',
-        description: 'Predictive preloading',
-        enabled: false,
-        headless: {
-            promptTemplate: `Based on recent activity, predict what the developer needs:
-- Files likely to be edited next
-- Tests that should be run
-- Documentation to reference
-- Dependencies to check
-
-Provide preload suggestions as JSON:
-{
-  "filesToPreload": ["..."],
-  "testsToRun": ["..."],
-  "docsToReference": ["..."],
-  "confidence": 0.0-1.0
-}`,
-            sandbox: 'strict',
-            model: 'haiku',
-            outputFormat: 'json',
-            contextPatterns: ['.moflo/metrics/*.json'],
-            timeoutMs: 2 * 60 * 1000,
-        },
-    },
 };
 /**
  * Local worker configurations

package/dist/src/cli/services/hook-block-hash.js

@@ -79,6 +79,10 @@ export function getReferenceHookBlock() {
             { matcher: '^mcp__moflo__memory_(search|retrieve|list|stats|store)$', hooks: [gateHook('record-memory-searched', 3000)] },
             { matcher: '^TaskUpdate$', hooks: [gateCjs('check-task-transition', 2000)] },
             { matcher: '^mcp__moflo__memory_store$', hooks: [gateCjs('record-learnings-stored', 2000)] },
+            // #952 — wired so /fl -s/--swarm and /fl -h/--hive runs satisfy the
+            // check-before-agent gate after the protected MCP init has been called.
+            { matcher: '^mcp__moflo__swarm_init$', hooks: [gateCjs('record-swarm-init', 2000)] },
+            { matcher: '^mcp__moflo__hive-mind_init$', hooks: [gateCjs('record-hive-init', 2000)] },
         ],
         UserPromptSubmit: [
             { hooks: [helperHook('prompt-hook.mjs', '', 3000)] },