moflo 4.9.22 → 4.9.23

package/dist/src/cli/commands/daemon.js

@@ -19,7 +19,7 @@ const startCommand = {
     name: 'start',
     description: 'Start the worker daemon with all enabled background workers',
     options: [
-        { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: map,audit,optimize,consolidate,testgaps)' },
+        { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: map,optimize,consolidate,testgaps)' },
         { name: 'quiet', short: 'Q', type: 'boolean', description: 'Suppress output' },
         { name: 'background', short: 'b', type: 'boolean', description: 'Run daemon in background (detached process)', default: true },
         { name: 'foreground', short: 'f', type: 'boolean', description: 'Run daemon in foreground (blocks terminal)' },
@@ -33,7 +33,7 @@ const startCommand = {
     examples: [
         { command: 'claude-flow daemon start', description: 'Start daemon in background (default)' },
         { command: 'claude-flow daemon start --foreground', description: 'Start in foreground (blocks terminal)' },
-        { command: 'claude-flow daemon start -w map,audit,optimize', description: 'Start with specific workers' },
+        { command: 'claude-flow daemon start -w map,optimize', description: 'Start with specific workers' },
         { command: 'claude-flow daemon start --headless --sandbox strict', description: 'Start with headless workers in strict sandbox' },
     ],
     action: async (ctx) => {
@@ -128,7 +128,7 @@ const startCommand = {
                     `Max Concurrent: ${status.config.maxConcurrent}`,
                     `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
                     `Min Free Memory: ${status.config.resourceThresholds.minFreeMemoryPercent}%`,
-                    ...(dashboard ? [`Dashboard: http://localhost:${dashboard.port}`] : []),
+                    ...(dashboard ? [`The Arcane Console: http://localhost:${dashboard.port}`] : []),
                 ].join('\n'), 'Daemon Status');
                 output.writeln();
                 output.writeln(output.bold('Scheduled Workers'));
@@ -215,10 +215,10 @@ async function attachDaemonServices(daemon, opts) {
                 schedulerEnabledInConfig: schedulerConfig.enabled,
             });
             if (opts.verbose)
-                output.printSuccess(`Dashboard: http://localhost:${dashboard.port}`);
+                output.printSuccess(`The Arcane Console: http://localhost:${dashboard.port}`);
         }
         catch (err) {
-            logWarn(`Dashboard failed to start: ${errorDetail(err)}`);
+            logWarn(`The Arcane Console failed to start: ${errorDetail(err)}`);
         }
     }
     if (!schedulerConfig.enabled) {
@@ -378,7 +378,7 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     if (!quiet) {
         output.printSuccess(`Daemon started in background (PID: ${pid})`);
         if (!noDashboard) {
-            output.printInfo(`Dashboard: http://localhost:${dashboardPort ?? DEFAULT_DASHBOARD_PORT}`);
+            output.printInfo(`The Arcane Console: http://localhost:${dashboardPort ?? DEFAULT_DASHBOARD_PORT}`);
         }
         output.printInfo(`Logs: ${logFile}`);
         output.printInfo(`Stop with: claude-flow daemon stop`);
@@ -624,15 +624,14 @@ const triggerCommand = {
     ],
     examples: [
         { command: 'claude-flow daemon trigger -w map', description: 'Trigger the map worker' },
-        { command: 'claude-flow daemon trigger -w audit', description: 'Trigger security audit' },
-        { command: 'claude-flow daemon trigger -w audit --headless', description: 'Trigger audit in headless sandbox' },
+        { command: 'claude-flow daemon trigger -w optimize --headless', description: 'Trigger optimize in headless sandbox' },
     ],
     action: async (ctx) => {
         const workerType = ctx.flags.worker;
         if (!workerType) {
             output.printError('Worker type is required. Use --worker or -w flag.');
             output.writeln();
-            output.writeln('Available workers: map, audit, optimize, consolidate, testgaps, predict, document, ultralearn, refactor, benchmark, deepdive, preload');
+            output.writeln('Available workers: map, optimize, consolidate, testgaps, ultralearn, refactor, benchmark, deepdive, preload');
             return { success: false, exitCode: 1 };
         }
         try {
@@ -668,8 +667,8 @@ const enableCommand = {
         { name: 'disable', short: 'd', type: 'boolean', description: 'Disable instead of enable' },
     ],
     examples: [
-        { command: 'claude-flow daemon enable -w predict', description: 'Enable predict worker' },
-        { command: 'claude-flow daemon enable -w document --disable', description: 'Disable document worker' },
+        { command: 'claude-flow daemon enable -w testgaps', description: 'Enable testgaps worker' },
+        { command: 'claude-flow daemon enable -w refactor --disable', description: 'Disable refactor worker' },
     ],
     action: async (ctx) => {
         const workerType = ctx.flags.worker;
@@ -799,7 +798,7 @@ export const daemonCommand = {
         { command: 'claude-flow daemon start --headless', description: 'Start with headless workers (E2B sandbox)' },
         { command: 'claude-flow daemon status', description: 'Check daemon status' },
         { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
-        { command: 'claude-flow daemon trigger -w audit', description: 'Run security audit' },
+        { command: 'claude-flow daemon trigger -w optimize', description: 'Run the optimize worker' },
         { command: 'claude-flow daemon install', description: 'Register as OS login service' },
         { command: 'claude-flow daemon uninstall', description: 'Remove OS login service' },
     ],
@@ -808,7 +807,7 @@ export const daemonCommand = {
         output.writeln(output.bold('MoFlo Daemon - Background Task Management'));
         output.writeln();
         output.writeln('Node.js-based background worker system that auto-runs like shell daemons.');
-        output.writeln('Manages 12 specialized workers for continuous optimization and monitoring.');
+        output.writeln('Manages 9 specialized workers for continuous optimization and monitoring.');
         output.writeln();
         output.writeln(output.bold('Headless Mode'));
         output.writeln('Workers can run in headless mode using E2B sandboxes for isolated execution.');
@@ -816,13 +815,10 @@ export const daemonCommand = {
         output.writeln();
         output.writeln(output.bold('Available Workers'));
         output.printList([
-            `${output.highlight('map')}         - Codebase mapping (5 min interval)`,
-            `${output.highlight('audit')}       - Security analysis (10 min interval)`,
+            `${output.highlight('map')}         - Codebase mapping (15 min interval)`,
             `${output.highlight('optimize')}    - Performance optimization (15 min interval)`,
             `${output.highlight('consolidate')} - Memory consolidation (30 min interval)`,
             `${output.highlight('testgaps')}    - Test coverage analysis (20 min interval)`,
-            `${output.highlight('predict')}     - Predictive preloading (2 min, disabled by default)`,
-            `${output.highlight('document')}    - Auto-documentation (60 min, disabled by default)`,
             `${output.highlight('ultralearn')}  - Deep knowledge acquisition (manual trigger)`,
             `${output.highlight('refactor')}    - Code refactoring suggestions (manual trigger)`,
             `${output.highlight('benchmark')}   - Performance benchmarking (manual trigger)`,

package/dist/src/cli/commands/hooks.js

@@ -1766,14 +1766,14 @@ const workerDispatchCommand = {
     name: 'dispatch',
     description: 'Dispatch a background worker for analysis/optimization',
     options: [
-        { name: 'trigger', short: 't', type: 'string', description: 'Worker type (ultralearn, optimize, audit, map, etc.)', required: true },
+        { name: 'trigger', short: 't', type: 'string', description: 'Worker type (ultralearn, optimize, map, testgaps, etc.)', required: true },
         { name: 'context', short: 'c', type: 'string', description: 'Context for the worker (file path, topic)' },
         { name: 'priority', short: 'p', type: 'string', description: 'Priority (low, normal, high, critical)' },
         { name: 'sync', short: 's', type: 'boolean', description: 'Wait for completion (synchronous)' },
     ],
     examples: [
         { command: 'claude-flow hooks worker dispatch -t optimize -c src/', description: 'Dispatch optimize worker' },
-        { command: 'claude-flow hooks worker dispatch -t audit -p critical', description: 'Security audit with critical priority' },
+        { command: 'claude-flow hooks worker dispatch -t deepdive -p high', description: 'Deep code analysis with high priority' },
         { command: 'claude-flow hooks worker dispatch -t testgaps --sync', description: 'Test coverage analysis (sync)' },
     ],
     action: async (ctx) => {
@@ -1783,7 +1783,7 @@ const workerDispatchCommand = {
         const background = !ctx.flags['sync'];
         if (!trigger) {
             output.printError('--trigger is required');
-            output.writeln('Available triggers: ultralearn, optimize, consolidate, predict, audit, map, preload, deepdive, document, refactor, benchmark, testgaps');
+            output.writeln('Available triggers: ultralearn, optimize, consolidate, map, preload, deepdive, refactor, benchmark, testgaps');
             return { success: false, exitCode: 1 };
         }
         const spinner = output.createSpinner({ text: `Dispatching ${trigger} worker...`, spinner: 'dots' });
@@ -2485,12 +2485,9 @@ const workerCommand = {
             `${output.highlight('ultralearn')}   - Deep knowledge acquisition`,
             `${output.highlight('optimize')}     - Performance optimization`,
             `${output.highlight('consolidate')} - Memory consolidation`,
-            `${output.highlight('predict')}      - Predictive preloading`,
-            `${output.highlight('audit')}        - Security analysis (critical)`,
             `${output.highlight('map')}          - Codebase mapping`,
             `${output.highlight('preload')}      - Resource preloading`,
             `${output.highlight('deepdive')}     - Deep code analysis`,
-            `${output.highlight('document')}     - Auto-documentation`,
             `${output.highlight('refactor')}     - Refactoring suggestions`,
             `${output.highlight('benchmark')}    - Performance benchmarks`,
             `${output.highlight('testgaps')}     - Test coverage analysis`,

package/dist/src/cli/commands/spell-schedule.js

@@ -15,8 +15,58 @@ import { callMCPTool } from '../mcp-client.js';
 import { TOOL_MEMORY_STORE, TOOL_MEMORY_LIST, TOOL_MEMORY_RETRIEVE } from '../mcp-tools/tool-names.js';
 import { handleMCPError } from '../services/cli-formatters.js';
 import { ensureDaemonForScheduling } from '../services/daemon-readiness.js';
+import { reconcileDaemonAutostart } from '../services/daemon-autostart-lifecycle.js';
+import { isDaemonInstalled } from '../services/daemon-service.js';
 import { validateSchedule, computeNextRun } from '../spells/scheduler/cron-parser.js';
 const NAMESPACE_SCHEDULES = 'scheduled-spells';
+const NAMESPACE_EXECUTIONS = 'schedule-executions';
+const DEFAULT_EXECUTIONS_LIMIT = 10;
+const MAX_NAMESPACE_FETCH = 1000;
+async function loadNamespaceValues(namespace, limit = MAX_NAMESPACE_FETCH) {
+    const listResult = await callMCPTool(TOOL_MEMORY_LIST, {
+        namespace,
+        limit,
+    });
+    const entries = listResult.entries ?? [];
+    // Parallelize retrieves — serial-await over N entries was the cost the
+    // reconcile-after-mutation path was paying on every create/cancel.
+    const fetched = await Promise.all(entries.map(async (entry) => {
+        try {
+            const result = await callMCPTool(TOOL_MEMORY_RETRIEVE, {
+                namespace,
+                key: entry.key,
+            });
+            if (result.value === null || result.value === undefined)
+                return null;
+            const parsed = typeof result.value === 'string'
+                ? JSON.parse(result.value)
+                : result.value;
+            return parsed;
+        }
+        catch {
+            output.printWarning(`Skipped malformed entry: ${entry.key}`);
+            return null;
+        }
+    }));
+    return fetched.filter((v) => v !== null);
+}
+/**
+ * Count enabled schedules in the `scheduled-spells` namespace. Drives the
+ * autostart reconcile after a create/cancel — see #960/#961.
+ */
+async function countEnabledSchedules() {
+    const records = await loadNamespaceValues(NAMESPACE_SCHEDULES);
+    return records.filter(r => r.enabled === true).length;
+}
+/**
+ * Run the autostart reconcile and surface its message/warning to the user.
+ */
+function emitReconcileResult(result) {
+    if (result.message)
+        output.printInfo(result.message);
+    if (result.warning)
+        output.printWarning(result.warning);
+}
 // ── Schedule Create ───────────────────────────────────────────────────────────
 const createCommand = {
     name: 'create',
@@ -26,11 +76,13 @@ const createCommand = {
         { name: 'cron', short: 'c', description: 'Cron expression (5-field)', type: 'string' },
         { name: 'interval', short: 'i', description: 'Interval (e.g., "6h", "30m", "1d")', type: 'string' },
         { name: 'at', short: 'a', description: 'One-time ISO 8601 datetime', type: 'string' },
+        { name: 'no-autostart', description: 'Do not register the daemon as an OS login service', type: 'boolean' },
     ],
     examples: [
         { command: 'moflo spell schedule create -n audit --cron "0 9 * * *"', description: 'Daily at 9am' },
         { command: 'moflo spell schedule create -n security-audit --interval 6h', description: 'Every 6 hours' },
         { command: 'moflo spell schedule create -n report --at 2026-04-01T09:00:00Z', description: 'One-time cast' },
+        { command: 'moflo spell schedule create -n audit --interval 6h --no-autostart', description: 'Skip OS login service registration (e.g., container/CI)' },
     ],
     action: async (ctx) => {
         const name = ctx.flags.name || ctx.args[0];
@@ -86,15 +138,41 @@ const createCommand = {
             source: 'adhoc',
         };
         try {
-            await callMCPTool(TOOL_MEMORY_STORE, {
+            const storeResult = await callMCPTool(TOOL_MEMORY_STORE, {
                 namespace: NAMESPACE_SCHEDULES,
                 key: id,
                 value: JSON.stringify(record),
+                upsert: true,
             });
+            if (storeResult.success === false) {
+                output.printError(`Failed to save schedule: ${storeResult.error ?? 'unknown error'}`);
+                return { success: false, exitCode: 1 };
+            }
         }
         catch (error) {
             return handleMCPError(error, 'save schedule');
         }
+        // Reconcile OS-native autostart against the new enabled-schedule count.
+        // 0→1 installs the login service; 1→2/2→3/etc. is a no-op (idempotent).
+        // Short-circuit: a fresh create can only ever trigger an install (count
+        // just went up). If the service is already installed, the reconcile is a
+        // guaranteed noop — skip the count fetch entirely.
+        // Note: parser normalises --no-autostart to ctx.flags.noAutostart (#787).
+        const skipAutostart = ctx.flags.noAutostart === true;
+        const alreadyInstalled = readiness.daemonInstalled;
+        let reconcileTransition = 'noop';
+        if (!skipAutostart && !alreadyInstalled) {
+            const reconcile = reconcileDaemonAutostart({
+                projectRoot,
+                enabledScheduleCount: await countEnabledSchedules(),
+                skip: false,
+            });
+            emitReconcileResult(reconcile);
+            reconcileTransition = reconcile.transition;
+        }
+        const serviceState = reconcileTransition === 'installed' || alreadyInstalled
+            ? 'installed'
+            : 'not installed';
         if (ctx.flags.format === 'json') {
             output.printJson(record);
             return { success: true, data: record };
@@ -109,7 +187,7 @@ const createCommand = {
             at ? `At: ${at}` : null,
             `Next Cast: ${new Date(nextRunAt).toLocaleString()}`,
             `Daemon: ${readiness.daemonRunning ? 'running' : 'not running'}`,
-            `Service: ${readiness.daemonInstalled ? 'installed' : 'not installed'}`,
+            `Service: ${serviceState}`,
         ].filter(Boolean).join('\n'), 'Scheduled Spell');
         return { success: true, data: record };
     },
@@ -127,61 +205,146 @@ const scheduleListCommand = {
     aliases: ['ls'],
     description: 'List all scheduled spells',
     action: async (ctx) => {
+        let raw;
         try {
-            const result = await callMCPTool(TOOL_MEMORY_LIST, {
-                namespace: NAMESPACE_SCHEDULES,
-            });
-            // Single-pass: parse + transform for display
-            const schedules = [];
-            for (const r of result.results ?? []) {
-                try {
-                    const parsed = typeof r.value === 'string' ? JSON.parse(r.value) : r.value;
-                    if (parsed) {
-                        schedules.push({
-                            id: parsed.id,
-                            spellName: parsed.spellName,
-                            timing: parsed.cron || parsed.interval || parsed.at || '-',
-                            nextRun: parsed.nextRunAt ? new Date(parsed.nextRunAt).toLocaleString() : '-',
-                            enabled: parsed.enabled,
-                        });
-                    }
-                }
-                catch {
-                    output.printWarning(`Skipped malformed schedule record: ${r.key}`);
-                }
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(schedules);
-                return { success: true, data: schedules };
-            }
-            if (schedules.length === 0) {
-                output.writeln();
-                output.printInfo('No scheduled spells');
-                return { success: true, data: [] };
-            }
-            output.writeln();
-            output.writeln(output.bold('Scheduled Spells'));
-            output.writeln();
-            output.printTable({ columns: SCHEDULE_COLUMNS, data: schedules });
-            output.writeln();
-            output.printInfo(`Total: ${schedules.length} schedule(s)`);
-            return { success: true, data: schedules };
+            raw = await loadNamespaceValues(NAMESPACE_SCHEDULES);
         }
         catch (error) {
             return handleMCPError(error, 'list schedules');
         }
+        const schedules = raw.map(parsed => ({
+            id: parsed.id,
+            spellName: parsed.spellName,
+            timing: parsed.cron || parsed.interval || parsed.at || '-',
+            nextRun: parsed.nextRunAt ? new Date(parsed.nextRunAt).toLocaleString() : '-',
+            enabled: parsed.enabled,
+        }));
+        if (ctx.flags.format === 'json') {
+            output.printJson(schedules);
+            return { success: true, data: schedules };
+        }
+        if (schedules.length === 0) {
+            output.writeln();
+            output.printInfo('No scheduled spells');
+            return { success: true, data: [] };
+        }
+        output.writeln();
+        output.writeln(output.bold('Scheduled Spells'));
+        output.writeln();
+        output.printTable({ columns: SCHEDULE_COLUMNS, data: schedules });
+        output.writeln();
+        output.printInfo(`Total: ${schedules.length} schedule(s)`);
+        return { success: true, data: schedules };
+    },
+};
+// ── Schedule Executions ───────────────────────────────────────────────────────
+const EXECUTION_COLUMNS = [
+    { key: 'startedAt', header: 'Started', width: 22 },
+    { key: 'spellName', header: 'Spell', width: 20 },
+    { key: 'status', header: 'Status', width: 10 },
+    { key: 'duration', header: 'Duration', width: 10 },
+    { key: 'manualRun', header: 'Manual', width: 7 },
+    { key: 'scheduleId', header: 'Schedule', width: 30 },
+];
+function formatExecutionRow(parsed) {
+    const completed = typeof parsed.completedAt === 'number';
+    let status;
+    if (!completed) {
+        status = output.warning('running');
+    }
+    else if (parsed.success === true) {
+        status = output.success('success');
+    }
+    else {
+        status = output.error('failed');
+    }
+    return {
+        id: String(parsed.id ?? ''),
+        scheduleId: String(parsed.scheduleId ?? ''),
+        spellName: String(parsed.spellName ?? ''),
+        startedAt: typeof parsed.startedAt === 'number'
+            ? new Date(parsed.startedAt).toLocaleString()
+            : '-',
+        status,
+        duration: typeof parsed.duration === 'number' ? `${parsed.duration}ms` : '-',
+        manualRun: parsed.manualRun === true ? 'yes' : '',
+    };
+}
+const executionsCommand = {
+    name: 'executions',
+    aliases: ['exec', 'history'],
+    description: 'Show recent scheduled spell executions',
+    options: [
+        { name: 'schedule', short: 's', description: 'Filter by schedule ID', type: 'string' },
+        { name: 'limit', short: 'l', description: `Max rows to return (default ${DEFAULT_EXECUTIONS_LIMIT})`, type: 'number' },
+    ],
+    examples: [
+        { command: 'moflo spell schedule executions', description: 'Most recent executions across all schedules' },
+        { command: 'moflo spell schedule executions --schedule sched-adhoc-123', description: 'Filter by schedule ID' },
+        { command: 'moflo spell schedule executions --limit 25', description: 'Show last 25 executions' },
+    ],
+    action: async (ctx) => {
+        const scheduleFilter = ctx.flags.schedule;
+        const rawLimit = ctx.flags.limit;
+        const limit = typeof rawLimit === 'number' && rawLimit > 0
+            ? Math.floor(rawLimit)
+            : DEFAULT_EXECUTIONS_LIMIT;
+        let raw;
+        try {
+            raw = await loadNamespaceValues(NAMESPACE_EXECUTIONS);
+        }
+        catch (error) {
+            return handleMCPError(error, 'list executions');
+        }
+        const parsed = raw.filter(v => typeof v.startedAt === 'number');
+        const filtered = scheduleFilter
+            ? parsed.filter(e => e.scheduleId === scheduleFilter)
+            : parsed;
+        filtered.sort((a, b) => b.startedAt - a.startedAt);
+        const truncated = filtered.slice(0, limit);
+        if (ctx.flags.format === 'json') {
+            output.printJson(truncated);
+            return { success: true, data: truncated };
+        }
+        if (truncated.length === 0) {
+            output.writeln();
+            output.printInfo(scheduleFilter
+                ? `No executions for schedule ${scheduleFilter}`
+                : 'No scheduled spell executions yet');
+            return { success: true, data: [] };
+        }
+        const rows = truncated.map(formatExecutionRow);
+        output.writeln();
+        output.writeln(output.bold(scheduleFilter
+            ? `Executions for ${scheduleFilter}`
+            : 'Recent Scheduled Executions'));
+        output.writeln();
+        output.printTable({ columns: EXECUTION_COLUMNS, data: rows });
+        output.writeln();
+        output.printInfo(filtered.length > truncated.length
+            ? `Showing ${truncated.length} of ${filtered.length} execution(s)`
+            : `Total: ${truncated.length} execution(s)`);
+        return { success: true, data: truncated };
     },
 };
 // ── Schedule Cancel ───────────────────────────────────────────────────────────
 const cancelCommand = {
     name: 'cancel',
     description: 'Cancel (disable) a scheduled spell',
+    options: [
+        { name: 'keep-autostart', description: 'Keep the OS login service registered even if no schedules remain', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'moflo spell schedule cancel sched-adhoc-123', description: 'Cancel and auto-uninstall daemon service if no schedules remain' },
+        { command: 'moflo spell schedule cancel sched-adhoc-123 --keep-autostart', description: 'Cancel but keep the OS login service registered' },
+    ],
     action: async (ctx) => {
         const scheduleId = ctx.args[0];
         if (!scheduleId) {
             output.printError('Schedule ID is required');
             return { success: false, exitCode: 1 };
         }
+        let updated;
         try {
             // Fetch the current schedule
             const fetchResult = await callMCPTool(TOOL_MEMORY_RETRIEVE, {
@@ -195,19 +358,42 @@ const cancelCommand = {
             const schedule = typeof fetchResult.value === 'string'
                 ? JSON.parse(fetchResult.value)
                 : fetchResult.value;
-            // Disable it
-            const updated = { ...schedule, enabled: false };
-            await callMCPTool(TOOL_MEMORY_STORE, {
+            // Disable it. upsert:true is critical — the cancel writes back to an
+            // existing key, and the historic default (insert-only) silently failed
+            // with a UNIQUE constraint violation on (namespace, key) — see #962.
+            updated = { ...schedule, enabled: false };
+            const storeResult = await callMCPTool(TOOL_MEMORY_STORE, {
                 namespace: NAMESPACE_SCHEDULES,
                 key: scheduleId,
                 value: JSON.stringify(updated),
+                upsert: true,
             });
-            output.printSuccess(`Schedule ${scheduleId} cancelled`);
-            return { success: true, data: updated };
+            if (storeResult.success === false) {
+                output.printError(`Failed to cancel schedule: ${storeResult.error ?? 'unknown error'}`);
+                return { success: false, exitCode: 1 };
+            }
         }
         catch (error) {
             return handleMCPError(error, 'cancel schedule');
         }
+        output.printSuccess(`Schedule ${scheduleId} cancelled`);
+        // Reconcile OS-native autostart against the new enabled-schedule count.
+        // 1→0 uninstalls the login service; everything else is a no-op.
+        // Short-circuit: a fresh cancel can only ever trigger an uninstall (count
+        // just went down). If the service isn't currently installed, the reconcile
+        // is a guaranteed noop — skip the count fetch entirely.
+        // Note: parser normalises --keep-autostart to ctx.flags.keepAutostart (#787).
+        const projectRoot = ctx.cwd || process.cwd();
+        const skipAutostart = ctx.flags.keepAutostart === true;
+        if (!skipAutostart && isDaemonInstalled(projectRoot)) {
+            const reconcile = reconcileDaemonAutostart({
+                projectRoot,
+                enabledScheduleCount: await countEnabledSchedules(),
+                skip: false,
+            });
+            emitReconcileResult(reconcile);
+        }
+        return { success: true, data: updated };
     },
 };
 // ── Schedule Command (parent) ─────────────────────────────────────────────────
@@ -215,10 +401,11 @@ const SCHEDULE_DOCS_URL = 'https://github.com/eric-cielo/moflo/blob/main/docs/SP
 export const scheduleCommand = {
     name: 'schedule',
     description: `Manage scheduled spells (full reference: ${SCHEDULE_DOCS_URL})`,
-    subcommands: [createCommand, scheduleListCommand, cancelCommand],
+    subcommands: [createCommand, scheduleListCommand, executionsCommand, cancelCommand],
     examples: [
         { command: 'moflo spell schedule create -n audit --cron "0 9 * * *"', description: 'Schedule daily audit' },
         { command: 'moflo spell schedule list', description: 'List all schedules' },
+        { command: 'moflo spell schedule executions --schedule <id>', description: 'Show execution audit trail' },
         { command: 'moflo spell schedule cancel <id>', description: 'Cancel a schedule' },
     ],
     action: async () => {
@@ -229,9 +416,10 @@ export const scheduleCommand = {
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
-            `${output.highlight('create')}  - Create a scheduled spell`,
-            `${output.highlight('list')}    - List all scheduled spells`,
-            `${output.highlight('cancel')}  - Cancel (disable) a schedule`,
+            `${output.highlight('create')}      - Create a scheduled spell`,
+            `${output.highlight('list')}        - List all scheduled spells`,
+            `${output.highlight('executions')}  - Show recent execution history`,
+            `${output.highlight('cancel')}      - Cancel (disable) a schedule`,
         ]);
         output.writeln();
         output.writeln(`Full reference: ${SCHEDULE_DOCS_URL}`);

package/dist/src/cli/init/settings-generator.js

@@ -105,9 +105,11 @@ export function generateSettings(options) {
         daemon: {
             autoStart: true,
             // Note: this list is documentation for the user — the daemon's actual
-            // worker registry lives in src/cli/services/worker-daemon.ts DEFAULT_WORKERS.
-            // 'audit' is intentionally absent here because it's default-disabled
-            // pending the perf fix in #631.
+            // worker registry lives in src/cli/services/worker-daemon.ts
+            // DEFAULT_WORKERS. The `audit`/`predict`/`document` workers were
+            // removed in #970 (no surfacing layer for findings + dashboard
+            // pollution); restore them as opt-in `flo doctor` one-shots if their
+            // value is ever re-established.
             workers: [
                 'map', // Codebase mapping
                 'optimize', // Performance optimization (high priority)
@@ -115,15 +117,12 @@ export function generateSettings(options) {
                 'testgaps', // Test coverage gaps
                 'ultralearn', // Deep knowledge acquisition
                 'deepdive', // Deep code analysis
-                'document', // Auto-documentation for ADRs
                 'refactor', // Refactoring suggestions (DDD alignment)
                 'benchmark', // Performance benchmarking
             ],
             schedules: {
-                audit: { interval: '1h', priority: 'critical' },
                 optimize: { interval: '30m', priority: 'high' },
                 consolidate: { interval: '2h', priority: 'low' },
-                document: { interval: '1h', priority: 'normal', triggers: ['adr-update', 'api-change'] },
                 deepdive: { interval: '4h', priority: 'normal', triggers: ['complex-change'] },
                 ultralearn: { interval: '1h', priority: 'normal' },
             },

package/dist/src/cli/mcp-tools/memory-tools.js

@@ -154,7 +154,7 @@ async function ensureInitialized() {
 export const memoryTools = [
     {
         name: 'memory_store',
-        description: 'Store a value in memory with vector embedding for semantic search (sql.js + HNSW backend). Use upsert=true to update existing keys.',
+        description: 'Store a value in memory with vector embedding for semantic search (sql.js + HNSW backend). Upserts by default — pass upsert:false to fail on duplicate keys.',
         category: 'memory',
         inputSchema: {
             type: 'object',
@@ -168,7 +168,7 @@ export const memoryTools = [
                     description: 'Optional tags for filtering',
                 },
                 ttl: { type: 'number', description: 'Time-to-live in seconds (optional)' },
-                upsert: { type: 'boolean', description: 'If true, update existing key instead of failing (default: false)' },
+                upsert: { type: 'boolean', description: 'If false, fail on duplicate keys instead of replacing (default: true)' },
             },
             required: ['key', 'value'],
         },
@@ -180,7 +180,9 @@ export const memoryTools = [
             const value = typeof input.value === 'string' ? input.value : JSON.stringify(input.value);
             const tags = input.tags || [];
             const ttl = input.ttl;
-            const upsert = input.upsert || false;
+            // #962: default upsert=true — silent UNIQUE-constraint failures on update
+            // were dropping schedule cancels and similar updates on the floor.
+            const upsert = input.upsert === false ? false : true;
             validateMemoryInput(key, value);
             const startTime = performance.now();
             try {
@@ -364,12 +366,21 @@ export const memoryTools = [
             const namespace = input.namespace || 'default';
             try {
                 const result = await deleteEntry({ key, namespace });
+                // Issue #963: surface the underlying reason when delete fails.
+                // `result.success` reflects whether the call itself succeeded; we
+                // require `deleted === true` for the MCP-level success boolean,
+                // and pass `result.error` through whenever the delete didn't take.
+                const deleted = result.deleted === true;
+                const errorReason = !deleted
+                    ? (result.error ?? `No entry deleted (key='${key}', namespace='${namespace}'); reason not reported by storage layer`)
+                    : undefined;
                 return {
-                    success: result.deleted,
+                    success: result.success === true && deleted,
                     key,
                     namespace,
-                    deleted: result.deleted,
+                    deleted,
                     backend: 'sql.js + HNSW',
+                    ...(errorReason ? { error: errorReason } : {}),
                 };
             }
             catch (error) {