moflo 4.9.22 → 4.9.24

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

@@ -44,11 +44,9 @@ export const EMBEDDING_MODEL_OPT_OUT = 'none';
  */
 export const EMBEDDING_MODEL_LEGACY_DEFAULT = 'local';
 /**
- * Namespaces that store internal moflo run-tracking, never user knowledge.
- * Writes here skip embedding generation entirely — both `embedding` and
- * `embedding_model` land as NULL, distinct from the opt-out path which still
- * tags rows with `'none'`. Existing rows in these namespaces are hard-deleted
- * on upgrade by `services/ephemeral-namespace-purge.ts`.
+ * Namespaces that skip embedding generation in the bridge write path. Rows
+ * land with both `embedding` and `embedding_model` NULL (distinct from the
+ * opt-out path which still tags rows with `'none'`).
  *
  * Members:
  * - `hive-mind`     — MCP broadcast traffic (msg:*, agent_join, consensus_propose)
@@ -56,7 +54,11 @@ export const EMBEDDING_MODEL_LEGACY_DEFAULT = 'local';
  * - `epic-state`    — Epic progress (epic-N, story-M) written by commands/epic.ts
  * - `test-bridge-fix` — Single 2026-04-23 row left over from a one-off test
  *
- * See story #729 for the source-trace and rationale.
+ * See story #729 for the source-trace and rationale. The session-start
+ * launcher only purges {@link PURGE_ON_SESSION_START_NAMESPACES} — a strict
+ * subset that *excludes* `tasklist`, because the dashboard's Flo Runs tab
+ * (`daemon-dashboard.ts handleSpells`) reads tasklist; purging it on every
+ * session would empty the tab between sessions (#968).
  */
 export const EPHEMERAL_NAMESPACES = new Set([
     'hive-mind',
@@ -64,6 +66,24 @@ export const EPHEMERAL_NAMESPACES = new Set([
     'epic-state',
     'test-bridge-fix',
 ]);
+/**
+ * Subset of {@link EPHEMERAL_NAMESPACES} that the session-start launcher
+ * hard-purges via `services/ephemeral-namespace-purge.ts`. Excludes
+ * `tasklist` — those rows back the dashboard's "Flo Runs" tab and are
+ * trimmed by row-count retention instead of bulk purge (#968).
+ */
+export const PURGE_ON_SESSION_START_NAMESPACES = new Set([
+    'hive-mind',
+    'epic-state',
+    'test-bridge-fix',
+]);
+/**
+ * Maximum number of `tasklist` rows kept across session restarts. The
+ * session-start retention pass deletes oldest rows beyond this cap, so the
+ * dashboard's "Flo Runs" tab shows recent history without unbounded growth
+ * (#968). Sized for ~2 weeks of /flo activity at typical use.
+ */
+export const TASKLIST_RETENTION_CAP = 200;
 let cachedEmbedder = null;
 let testOverride = null;
 class LazyFastembedBridgeEmbedder {

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

@@ -435,14 +435,30 @@ export async function bridgeGetEntry(options) {
     });
 }
 /**
- * Soft-delete an entry. Guarded, cache-invalidated, attested.
+ * Hard-delete an entry. Guarded, cache-invalidated, attested.
+ *
+ * Failure modes (issue #963): every non-success path now carries a
+ * human-readable `error` so MCP callers can surface the reason instead
+ * of seeing a silent `{ deleted: false }`.
  */
 export async function bridgeDeleteEntry(options) {
     return withDb(options.dbPath, async (ctx, registry) => {
         const { key, namespace = 'default' } = options;
+        const deleteFail = (error) => ({ success: false, deleted: false, key, namespace, remainingEntries: 0, error });
         const guardResult = await guardValidate(registry, 'delete', { key, namespace });
         if (!guardResult.allowed) {
-            return { success: false, deleted: false, key, namespace, remainingEntries: 0, error: `MutationGuard rejected: ${guardResult.reason}` };
+            return deleteFail(`MutationGuard rejected: ${guardResult.reason}`);
+        }
+        let existed = false;
+        try {
+            const existsRows = execRows(ctx.db, `SELECT 1 as found FROM memory_entries WHERE key = ? AND namespace = ? AND status = 'active' LIMIT 1`, [key, namespace]);
+            existed = existsRows.length > 0;
+        }
+        catch (err) {
+            return deleteFail(`DB read failed during delete pre-check: ${errorDetail(err)}`);
+        }
+        if (!existed) {
+            return deleteFail(`Key '${key}' not found in namespace '${namespace}'`);
         }
         let changes = 0;
         try {
@@ -454,28 +470,30 @@ export async function bridgeDeleteEntry(options) {
             // db.getRowsModified() to read the row count from the last statement.
             changes = ctx.db.getRowsModified?.() ?? 0;
         }
-        catch {
-            return null;
+        catch (err) {
+            return deleteFail(`DELETE failed: ${errorDetail(err)}`);
         }
-        if (changes > 0)
-            persistBridgeDb(ctx.db, options.dbPath);
-        await cacheInvalidate(registry, makeEntryCacheKey(namespace, key));
-        if (changes > 0) {
-            await logAttestation(registry, 'delete', key, { namespace });
+        if (changes === 0) {
+            // SELECT found the row but DELETE removed nothing. Most likely cause:
+            // bridge holds an in-memory snapshot that diverged from disk
+            // (sql.js writeback semantics — see feedback_sqljs_writeback_clobber.md).
+            return deleteFail(`Internal inconsistency: row matched SELECT but DELETE removed 0 rows (key='${key}', namespace='${namespace}'). Possible bridge cache staleness — restart the daemon and retry.`);
         }
+        persistBridgeDb(ctx.db, options.dbPath);
+        await cacheInvalidate(registry, makeEntryCacheKey(namespace, key));
+        await logAttestation(registry, 'delete', key, { namespace });
         let remaining = 0;
         try {
-            const result = ctx.db.exec(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
-            remaining = result[0]?.values?.[0]?.[0] ?? 0;
+            const countRows = execRows(ctx.db, `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
+            remaining = Number(countRows[0]?.cnt ?? 0);
         }
         catch {
-            // Non-fatal
+            // Non-fatal — count is informational
         }
-        if (changes > 0)
-            refreshVectorStatsCache();
+        refreshVectorStatsCache();
         return {
             success: true,
-            deleted: changes > 0,
+            deleted: true,
             key,
             namespace,
             remainingEntries: remaining,

package/dist/src/cli/services/daemon-autostart-lifecycle.js

@@ -0,0 +1,62 @@
+/**
+ * Daemon Autostart Lifecycle
+ *
+ * Reconciles the OS-native daemon login service against the count of enabled
+ * scheduled spells. Replaces the old prompt-based flow in `daemon-readiness.ts`
+ * (which left users with stale autostart entries when their last schedule was
+ * cancelled — see #960, #961).
+ *
+ * Idempotent: callers invoke `reconcileDaemonAutostart` after every mutation
+ * to `scheduled-spells`. It installs once, uninstalls once, and is a no-op
+ * for every other transition.
+ */
+import { isDaemonInstalled as defaultIsDaemonInstalled, installDaemonService as defaultInstallDaemonService, uninstallDaemonService as defaultUninstallDaemonService, } from './daemon-service.js';
+const NOOP = { transition: 'noop', message: null, warning: null };
+/**
+ * Reconcile OS-native daemon autostart against schedule count.
+ *
+ * - count ≥ 1 + not installed → install
+ * - count = 0 + installed     → uninstall
+ * - all other states          → noop
+ *
+ * Never throws. Install/uninstall failures are returned as non-fatal warnings
+ * — the caller decides whether to print them. The schedule mutation itself is
+ * always considered the primary operation; autostart is best-effort.
+ */
+export function reconcileDaemonAutostart(options) {
+    if (options.skip)
+        return NOOP;
+    const isInstalled = (options.isDaemonInstalled ?? defaultIsDaemonInstalled)(options.projectRoot);
+    if (options.enabledScheduleCount >= 1 && !isInstalled) {
+        const result = (options.installDaemonService ?? defaultInstallDaemonService)(options.projectRoot);
+        if (result.success) {
+            return {
+                transition: 'installed',
+                message: 'Daemon registered as OS login service so this schedule survives reboot.',
+                warning: null,
+            };
+        }
+        return {
+            transition: 'noop',
+            message: null,
+            warning: `Could not register daemon as OS login service: ${result.message}`,
+        };
+    }
+    if (options.enabledScheduleCount === 0 && isInstalled) {
+        const result = (options.uninstallDaemonService ?? defaultUninstallDaemonService)(options.projectRoot);
+        if (result.success) {
+            return {
+                transition: 'uninstalled',
+                message: 'No enabled schedules remain — daemon unregistered from OS login services.',
+                warning: null,
+            };
+        }
+        return {
+            transition: 'noop',
+            message: null,
+            warning: `Could not unregister daemon from OS login services: ${result.message}`,
+        };
+    }
+    return NOOP;
+}
+//# sourceMappingURL=daemon-autostart-lifecycle.js.map

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

@@ -1,8 +1,14 @@
 /**
- * Daemon Dashboard — Lightweight localhost HTTP server
+ * The Luminarium — 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 Luminarium (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,33 @@ 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 Luminarium</title>
+  <meta name="description" content="The Luminarium — moflo daemon, scheduled spells, and live event stream">
+  <meta property="og:title" content="The Luminarium">
+  <meta property="og:description" content="The Luminarium — 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; }
+    /* Luminous gradient flowing across the whole title (amber → pale gold → pale
+       cyan). background-clip: text paints the gradient through the glyphs;
+       color: transparent reveals it. text-shadow doesn't paint on transparent
+       text, so the glow uses filter: drop-shadow which respects rendered
+       glyph shape. Mid-gradient hue chosen for the glow tint. */
+    h1 .luminarium-title {
+      background: linear-gradient(90deg, #f59e0b 0%, #fde68a 50%, #67e8f4 100%);
+      -webkit-background-clip: text;
+      background-clip: text;
+      color: transparent;
+      filter: drop-shadow(0 0 14px rgba(253, 230, 138, 0.22));
+    }
     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 +634,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="luminarium-title">The Luminarium</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 +716,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 +756,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 +797,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) {