moflo 4.9.21 → 4.9.23

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/hooks/reasoningbank/index.js

@@ -33,15 +33,15 @@ const DEFAULT_CONFIG = {
     useMockEmbeddings: false,
 };
 /**
- * Agent mapping for routing
+ * Agent mapping for routing — keys must match agents shipped in .claude/agents/
+ * (or the canonical AgentType union).
  */
 const AGENT_PATTERNS = {
-    'security-architect': /security|auth|cve|vuln|encrypt|password|token/i,
-    'test-architect': /test|spec|mock|coverage|tdd|assert/i,
-    'performance-engineer': /perf|optim|fast|memory|cache|speed|slow/i,
-    'core-architect': /architect|design|ddd|domain|refactor|struct/i,
-    'swarm-specialist': /swarm|agent|coordinate|orchestrat|parallel/i,
-    'memory-specialist': /memory|agentdb|hnsw|vector|embedding/i,
+    'security-auditor': /security|auth|cve|vuln|encrypt|password|token/i,
+    'tester': /test|spec|mock|coverage|tdd|assert/i,
+    'architect': /architect|design|ddd|domain|refactor|struct|perf|optim|fast|memory|cache|speed|slow/i,
+    'coordinator': /swarm|agent|coordinate|orchestrat|parallel|hive/i,
+    'researcher': /memory|agentdb|hnsw|vector|embedding|recall|persist/i,
     'coder': /fix|bug|implement|create|add|build|error|code/i,
     'reviewer': /review|quality|lint|check|audit/i,
 };

package/dist/src/cli/init/executor.js

@@ -59,41 +59,28 @@ export const INTERNAL_SKILLS = [
 /**
  * Commands to copy based on configuration
  */
-const COMMANDS_MAP = {
-    core: ['claude-flow-help.md', 'claude-flow-swarm.md', 'claude-flow-memory.md', 'flo-simplify.md'],
-    analysis: [],
-    automation: [],
-    github: ['github'],
-    hooks: ['hooks'],
-    monitoring: [],
-    optimization: [],
-    sparc: ['sparc'],
-};
+// Empty after #949 retired the last shipped slash commands. moflo's user-facing
+// functionality now lives entirely in `.claude/skills/` (canonical) and
+// `.claude/agents/` (subagent surface). Kept as an empty-record placeholder
+// because callers iterate `Object.entries(COMMANDS_MAP)` to gate per-category
+// install — see init-copy-maps.test.ts for the iteration contract.
+const COMMANDS_MAP = {};
 /**
  * Agents to copy based on configuration. Exported for integrity tests.
+ *
+ * Each value is a directory name under `.claude/agents/` that ships in the
+ * moflo package. After #932 retired ~50 ruflo-aspirational agents, the set
+ * is narrowed to actual development specialties Claude is likely to invoke.
  */
 export const AGENTS_MAP = {
     core: ['core'],
-    consensus: ['consensus'],
-    github: ['github'],
-    hiveMind: ['hive-mind'],
-    sparc: ['sparc'],
-    swarm: ['swarm'],
-    browser: ['browser'], // agent-browser integration
-    // V3-specific agents
-    v3: ['v3'],
-    optimization: ['optimization'],
-    testing: ['testing'],
     analysis: ['analysis'],
     architecture: ['architecture'],
+    custom: ['custom'],
     development: ['development'],
     devops: ['devops'],
     documentation: ['documentation'],
-    specialized: ['specialized'],
-    goal: ['goal'],
-    sona: ['sona'],
-    data: ['data'],
-    custom: ['custom'],
+    security: ['security'],
 };
 /**
  * Directory structure to create
@@ -1521,39 +1508,24 @@ npx moflo swarm monitor
 ### Core Development (5)
 \`coder\`, \`reviewer\`, \`tester\`, \`planner\`, \`researcher\`
 
-### V3 Specialized (4)
-\`security-architect\`, \`security-auditor\`, \`memory-specialist\`, \`performance-engineer\`
-
-### Swarm Coordination (5)
-\`hierarchical-coordinator\`, \`mesh-coordinator\`, \`adaptive-coordinator\`, \`collective-intelligence-coordinator\`, \`swarm-memory-manager\`
-
-### Consensus & Distributed (7)
-\`byzantine-coordinator\`, \`raft-manager\`, \`gossip-coordinator\`, \`consensus-builder\`, \`crdt-synchronizer\`, \`quorum-manager\`, \`security-manager\`
-
-### Performance & Optimization (5)
-\`perf-analyzer\`, \`performance-benchmarker\`, \`task-orchestrator\`, \`memory-coordinator\`, \`smart-agent\`
-
-### GitHub & Repository (9)
-\`github-modes\`, \`pr-manager\`, \`code-review-swarm\`, \`issue-tracker\`, \`release-manager\`, \`workflow-automation\`, \`project-board-sync\`, \`repo-architect\`, \`multi-repo-swarm\`
-
-### SPARC Methodology (6)
-\`sparc-coord\`, \`sparc-coder\`, \`specification\`, \`pseudocode\`, \`architecture\`, \`refinement\`
+### Code Analysis (2)
+\`code-analyzer\`, \`analyst\`
 
-### Specialized Development (8)
-\`backend-dev\`, \`mobile-dev\`, \`ml-developer\`, \`cicd-engineer\`, \`api-docs\`, \`system-architect\`, \`code-analyzer\`, \`base-template-generator\`
+### Specialized Development (5)
+\`backend-dev\`, \`frontend-dev\`, \`database-dev\`, \`cicd-engineer\`, \`api-docs\`
 
-### Testing & Validation (2)
-\`tdd-london-swarm\`, \`production-validator\`
+### Security (1)
+\`security-auditor\`
 
 ### Agent Routing by Task
-| Task Type | Recommended Agents | Topology |
-|-----------|-------------------|----------|
-| Bug Fix | researcher, coder, tester | mesh |
-| New Feature | coordinator, architect, coder, tester, reviewer | hierarchical |
-| Refactoring | architect, coder, reviewer | mesh |
-| Performance | researcher, perf-engineer, coder | hierarchical |
-| Security | security-architect, auditor, reviewer | hierarchical |
-| Docs | researcher, api-docs | mesh |
+| Task Type | Recommended Agents |
+|-----------|--------------------|
+| Bug Fix | researcher, coder, tester |
+| New Feature | planner, coder, tester, reviewer |
+| Refactoring | coder, reviewer |
+| Security | security-auditor, reviewer |
+| GitHub workflow | coder, reviewer (with \`gh\` CLI) |
+| Docs | researcher, api-docs |
 
 ---
 

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

@@ -207,7 +207,7 @@ var path = require('path');
 var PROJECT_DIR = (process.env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\\/([a-z])\\//i, '$1:/');
 var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
 
-var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {} };
+var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, interactionCount: 0, sessionStart: null, lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {}, flMode: null, swarmInitialized: false, hiveInitialized: false };
 
 function readState() {
   try {
@@ -255,7 +255,7 @@ function writeState(s) {
 
 // Load moflo.yaml gate config (defaults: all enabled)
 function loadGateConfig() {
-  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true };
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true, swarm_invocation_gate: true };
   try {
     var yamlPath = path.join(PROJECT_DIR, 'moflo.yaml');
     if (fs.existsSync(yamlPath)) {
@@ -266,6 +266,7 @@ function loadGateConfig() {
       if (/testing_gate:\\s*false/i.test(content)) defaults.testing_gate = false;
       if (/simplify_gate:\\s*false/i.test(content)) defaults.simplify_gate = false;
       if (/learnings_gate:\\s*false/i.test(content)) defaults.learnings_gate = false;
+      if (/swarm_invocation_gate:\\s*false/i.test(content)) defaults.swarm_invocation_gate = false;
     }
   } catch (e) { /* use defaults */ }
   return defaults;
@@ -305,6 +306,21 @@ var NS_NAV_RES = [
   /\\b(class|function|method|component|service|entity|module)\\b/,
 ];
 
+// Detect whether the current prompt invoked /fl or /flo with a swarm/hive flag
+// (#952). When set, check-before-agent BLOCKS the Agent spawn until the matching
+// MCP init has been recorded — the user explicitly opted in to the protected
+// coordination surface, so falling back to raw Agent dispatch silently regresses
+// headline moflo product capability.
+//
+// SYNC: duplicated verbatim in bin/gate.cjs.
+function detectFlMode(promptText) {
+  var p = promptText || '';
+  if (!/^\\s*\\/(?:fl|flo)\\b/i.test(p)) return null;
+  if (/(?:^|\\s)(?:-s|--swarm)\\b/.test(p)) return 'swarm';
+  if (/(?:^|\\s)(?:-h|--hive)\\b/.test(p)) return 'hive';
+  return null;
+}
+
 function classifyNamespaceHint(promptText) {
   var lower = (promptText || '').toLowerCase();
   if (NS_TEST_RE.test(lower)) return 'Memory namespace hint: use "tests" for test inventory and coverage lookups.';
@@ -334,6 +350,11 @@ function applyPromptStateReset(state, promptText) {
   // Per-actor emission tracking — fresh window each prompt so subagents that
   // spawn their own agents still see the hint on their first check-before-agent.
   state.lastNamespaceHintEmittedBy = {};
+  // #952 — derive flMode from the user prompt and reset the matching init
+  // flag. Each /fl invocation must call its protected MCP init.
+  state.flMode = detectFlMode(promptText);
+  state.swarmInitialized = false;
+  state.hiveInitialized = false;
 }
 var TEST_RUNNER_RE = /(?:^|[^a-z])(?:npm|yarn|pnpm|bun)\\s+(?:run\\s+)?(?:test|t)(?:[:\\s]|$)|\\b(?:npx|pnpx)\\s+(?:vitest|jest|mocha|ava|tap|jasmine|pytest)\\b|(?:^|;|&&|\\|\\|)\\s*(?:vitest|jest|pytest|mocha|jasmine|tap|ava)\\s|\\b(?:cargo|go|deno|dotnet|mvn)\\s+test\\b|\\bgradle\\w*\\s+test\\b/i;
 var EDIT_RESET_SKIP_BOTH_RE = /\\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^|[\\\\\\/])(CHANGELOG(?:\\.md)?|\\.env\\.example|package-lock\\.json|pnpm-lock\\.yaml|yarn\\.lock|bun\\.lockb)$/i;
@@ -373,6 +394,46 @@ switch (command) {
         writeState(s);
       }
     }
+    // #952 — when /fl was invoked with -s/-h, the protected MCP init must run
+    // BEFORE any Agent spawn. Hard block: the user explicitly opted in to
+    // moflo's coordination surface, so silently dispatching Agent calls
+    // without mcp__moflo__swarm_init / mcp__moflo__hive-mind_init is the
+    // failure mode this gate exists to prevent (CLAUDE.md "⛔ Protected
+    // functionality"). Other Agent uses remain advisory.
+    if (config.swarm_invocation_gate) {
+      if (s.flMode === 'swarm' && !s.swarmInitialized) {
+        process.stderr.write('BLOCKED: /fl was invoked with -s/--swarm but mcp__moflo__swarm_init has not been called.\\n');
+        process.stderr.write('Run mcp__moflo__swarm_init first, then mcp__moflo__agent_spawn for each role, then dispatch Agent.\\n');
+        process.stderr.write('See .claude/skills/fl/execution-modes.md "SWARM mode" and CLAUDE.md "⛔ Protected functionality".\\n');
+        process.stderr.write('Disable via moflo.yaml: gates: swarm_invocation_gate: false\\n');
+        process.exit(2);
+      }
+      if (s.flMode === 'hive' && !s.hiveInitialized) {
+        process.stderr.write('BLOCKED: /fl was invoked with -h/--hive but mcp__moflo__hive-mind_init has not been called.\\n');
+        process.stderr.write('Run mcp__moflo__hive-mind_init first, then dispatch Agent or hive-mind workers.\\n');
+        process.stderr.write('See .claude/skills/fl/execution-modes.md "HIVE-MIND mode" and CLAUDE.md "⛔ Protected functionality".\\n');
+        process.stderr.write('Disable via moflo.yaml: gates: swarm_invocation_gate: false\\n');
+        process.exit(2);
+      }
+    }
+    break;
+  }
+  case 'record-swarm-init': {
+    // #952 — wired to mcp__moflo__swarm_init PostToolUse.
+    var s = readState();
+    if (!s.swarmInitialized) {
+      s.swarmInitialized = true;
+      writeState(s);
+    }
+    break;
+  }
+  case 'record-hive-init': {
+    // #952 — wired to mcp__moflo__hive-mind_init PostToolUse.
+    var s = readState();
+    if (!s.hiveInitialized) {
+      s.hiveInitialized = true;
+      writeState(s);
+    }
     break;
   }
   case 'check-before-scan': {
@@ -533,7 +594,9 @@ switch (command) {
     break;
   }
   case 'session-reset': {
-    writeState({ tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, interactionCount: 0, sessionStart: new Date().toISOString(), lastBlockedAt: null, lastNamespaceHint: '', lastNamespaceHintEmittedBy: {} });
+    // Derive from STATE_DEFAULTS so adding a new state field requires only one
+    // edit (the defaults object).
+    writeState(Object.assign({}, STATE_DEFAULTS, { sessionStart: new Date().toISOString() }));
     break;
   }
   default: