moflo 4.9.21 → 4.9.22

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:

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

@@ -302,6 +302,18 @@ function generateHooksConfig(config) {
                 matcher: '^mcp__moflo__memory_store$',
                 hooks: [{ type: 'command', command: gateCmd('record-learnings-stored'), timeout: 2000 }],
             },
+            {
+                // #952 — when /fl is invoked with -s/--swarm, the gate blocks Agent
+                // spawns until mcp__moflo__swarm_init runs. Record the call here so
+                // the hard block in check-before-agent passes for legitimate /fl runs.
+                matcher: '^mcp__moflo__swarm_init$',
+                hooks: [{ type: 'command', command: gateCmd('record-swarm-init'), timeout: 2000 }],
+            },
+            {
+                // #952 — symmetric record for /fl -h/--hive runs.
+                matcher: '^mcp__moflo__hive-mind_init$',
+                hooks: [{ type: 'command', command: gateCmd('record-hive-init'), timeout: 2000 }],
+            },
         ];
     }
     // UserPromptSubmit — per-prompt state reset + Context warnings.

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

@@ -27,33 +27,16 @@ const CANONICAL_AGENT_TYPES = [
 ];
 const ALLOWED_AGENT_TYPES = new Set([
     ...CANONICAL_AGENT_TYPES,
-    // Shipped Claude Code agent definitions (.claude/agents/**)
-    'adaptive-coordinator', 'adr-architect', 'aidefence-guardian',
+    // Claude Code built-ins
+    'claude-code-guide', 'general-purpose',
+    // Shipped Claude Code agent definitions (.claude/agents/**) — both the
+    // canonical `name:` slug and the file basename are accepted.
     'analyze-code-quality', 'api-docs', 'arch-system-design',
-    'backend-dev', 'base-template-generator', 'benchmark-suite',
-    'byzantine-coordinator', 'cicd-engineer', 'claims-authorizer',
-    'claude-code-guide', 'code-analyzer', 'code-goal-planner',
-    'code-review-swarm', 'collective-intelligence-coordinator',
-    'crdt-synchronizer', 'data-ml-model', 'ddd-domain-expert',
-    'dev-backend-api', 'docs-api-openapi', 'general-purpose',
-    'github-modes', 'goal-planner', 'gossip-coordinator',
-    'hierarchical-coordinator', 'injection-analyst', 'issue-tracker',
-    'load-balancer', 'memory-specialist', 'mesh-coordinator',
-    'ml-developer', 'mobile-dev', 'multi-repo-swarm',
-    'ops-cicd-github', 'performance-benchmarker', 'performance-engineer',
-    'performance-monitor', 'pii-detector', 'planner',
-    'pr-manager', 'production-validator', 'project-board-sync',
-    'pseudocode', 'quorum-manager', 'queen-coordinator',
-    'raft-manager', 'reasoningbank-learner', 'refinement',
-    'release-manager', 'release-swarm', 'repo-architect',
-    'resource-allocator', 'safla-neural', 'scout-explorer',
-    'security-architect', 'security-architect-aidefence',
-    'security-auditor', 'security-manager', 'sona-learning-optimizer',
-    'sparc-orchestrator', 'spec-mobile-react-native', 'specification',
-    'swarm-issue', 'swarm-memory-manager', 'swarm-pr',
-    'sync-coordinator', 'system-architect', 'tdd-london-swarm',
-    'test-long-runner', 'topology-optimizer', 'v3-integration-architect',
-    'workflow-automation', 'worker-specialist',
+    'backend-dev', 'base-template-generator', 'cicd-engineer',
+    'code-analyzer', 'database-dev', 'dev-backend-api',
+    'dev-database', 'dev-frontend', 'docs-api-openapi',
+    'frontend-dev', 'ops-cicd-github', 'planner',
+    'security-auditor', 'system-architect', 'test-long-runner',
 ]);
 const AGENT_TYPE_SLUG_RE = /^[a-z][a-z0-9-]*$/;
 export function toNonNegativeInt(value, fallback) {
@@ -78,7 +61,6 @@ export function validateAgentType(value) {
 const AGENT_TYPE_MODEL_DEFAULTS = {
     // Complex agents → opus
     'architect': 'opus',
-    'security-architect': 'opus',
     'system-architect': 'opus',
     'core-architect': 'opus',
     // Medium complexity → sonnet

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

@@ -211,7 +211,7 @@ function learnedPatternsFromOutcomes() {
 const TASK_PATTERNS = {
     'security-task': {
         keywords: ['authentication', 'security', 'auth', 'password', 'encryption', 'vulnerability', 'cve', 'audit'],
-        agents: ['security-architect', 'security-auditor', 'reviewer'],
+        agents: ['security-auditor', 'reviewer'],
     },
     'testing-task': {
         keywords: ['test', 'testing', 'spec', 'coverage', 'unit test', 'integration test', 'e2e'],
@@ -223,7 +223,7 @@ const TASK_PATTERNS = {
     },
     'performance-task': {
         keywords: ['performance', 'optimize', 'speed', 'memory', 'benchmark', 'profiling', 'bottleneck'],
-        agents: ['performance-engineer', 'coder', 'tester'],
+        agents: ['reviewer', 'coder', 'tester'],
     },
     'refactor-task': {
         keywords: ['refactor', 'restructure', 'clean', 'organize', 'modular', 'decouple'],
@@ -239,23 +239,25 @@ const TASK_PATTERNS = {
     },
     'database-task': {
         keywords: ['database', 'sql', 'query', 'schema', 'migration', 'orm'],
-        agents: ['architect', 'coder', 'tester'],
+        agents: ['database-dev', 'coder', 'tester'],
     },
     'frontend-task': {
-        keywords: ['frontend', 'ui', 'component', 'react', 'css', 'style', 'layout'],
-        agents: ['coder', 'reviewer', 'tester'],
+        keywords: ['frontend', 'ui', 'component', 'react', 'vue', 'svelte', 'css', 'tailwind', 'style', 'layout', 'accessibility'],
+        agents: ['frontend-dev', 'reviewer', 'tester'],
     },
     'devops-task': {
         keywords: ['deploy', 'ci', 'cd', 'pipeline', 'docker', 'kubernetes', 'infrastructure'],
-        agents: ['devops', 'coder', 'tester'],
+        agents: ['cicd-engineer', 'coder', 'tester'],
     },
+    // (github-task intent removed — github work routes to generic coder/reviewer
+    // with the gh CLI; specialized github-* agents were retired in #932)
     'swarm-task': {
         keywords: ['swarm', 'agent', 'coordinator', 'hive', 'mesh', 'topology'],
-        agents: ['swarm-specialist', 'coordinator', 'architect'],
+        agents: ['coordinator', 'architect'],
     },
     'memory-task': {
         keywords: ['memory', 'cache', 'store', 'vector', 'embedding', 'persistence'],
-        agents: ['memory-specialist', 'architect', 'coder'],
+        agents: ['researcher', 'architect', 'coder'],
     },
 };
 /**
@@ -436,30 +438,30 @@ const AGENT_PATTERNS = {
     '.yaml': ['coder', 'devops'],
     '.yml': ['coder', 'devops'],
     '.sh': ['devops', 'coder'],
-    '.py': ['coder', 'ml-developer', 'researcher'],
+    '.py': ['coder', 'researcher'],
     '.sql': ['coder', 'architect'],
     '.css': ['coder', 'designer'],
     '.scss': ['coder', 'designer'],
 };
 // Keyword patterns for fallback routing (when semantic routing doesn't match)
 const KEYWORD_PATTERNS = {
-    'authentication': { agents: ['security-architect', 'coder', 'tester'], confidence: 0.9 },
-    'auth': { agents: ['security-architect', 'coder', 'tester'], confidence: 0.85 },
+    'authentication': { agents: ['security-auditor', 'coder', 'tester'], confidence: 0.9 },
+    'auth': { agents: ['security-auditor', 'coder', 'tester'], confidence: 0.85 },
     'api': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
     'test': { agents: ['tester', 'reviewer'], confidence: 0.95 },
     'refactor': { agents: ['architect', 'coder', 'reviewer'], confidence: 0.9 },
-    'performance': { agents: ['performance-engineer', 'coder', 'tester'], confidence: 0.88 },
-    'security': { agents: ['security-architect', 'security-auditor', 'reviewer'], confidence: 0.92 },
-    'database': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
-    'frontend': { agents: ['coder', 'designer', 'tester'], confidence: 0.82 },
-    'backend': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
+    'performance': { agents: ['reviewer', 'coder', 'tester'], confidence: 0.88 },
+    'security': { agents: ['security-auditor', 'reviewer'], confidence: 0.92 },
+    'database': { agents: ['database-dev', 'coder', 'tester'], confidence: 0.9 },
+    'frontend': { agents: ['frontend-dev', 'reviewer', 'tester'], confidence: 0.9 },
+    'backend': { agents: ['backend-dev', 'architect', 'coder', 'tester'], confidence: 0.9 },
     'bug': { agents: ['coder', 'tester', 'reviewer'], confidence: 0.88 },
     'fix': { agents: ['coder', 'tester', 'reviewer'], confidence: 0.85 },
     'feature': { agents: ['architect', 'coder', 'tester'], confidence: 0.8 },
-    'swarm': { agents: ['swarm-specialist', 'coordinator', 'architect'], confidence: 0.9 },
-    'memory': { agents: ['memory-specialist', 'architect', 'coder'], confidence: 0.88 },
-    'deploy': { agents: ['devops', 'coder', 'tester'], confidence: 0.85 },
-    'ci/cd': { agents: ['devops', 'coder'], confidence: 0.9 },
+    'swarm': { agents: ['coordinator', 'architect'], confidence: 0.9 },
+    'memory': { agents: ['researcher', 'architect', 'coder'], confidence: 0.88 },
+    'deploy': { agents: ['cicd-engineer', 'coder', 'tester'], confidence: 0.85 },
+    'ci/cd': { agents: ['cicd-engineer', 'coder'], confidence: 0.9 },
 };
 function getFileExtension(filePath) {
     const match = filePath.match(/\.[a-zA-Z0-9]+$/);
@@ -1675,7 +1677,7 @@ export const hooksBuildAgents = {
             { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['flash-attention', 'token-reduction'] },
             { type: 'architect', configFile: join(outputDir, `architect.${format}`), capabilities: ['system-design', 'api-design', 'documentation'], optimizations: ['context-caching', 'memory-persistence'] },
             { type: 'tester', configFile: join(outputDir, `tester.${format}`), capabilities: ['unit-testing', 'integration-testing', 'coverage'], optimizations: ['parallel-execution'] },
-            { type: 'security-architect', configFile: join(outputDir, `security-architect.${format}`), capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
+            { type: 'security-auditor', configFile: join(outputDir, `security-auditor.${format}`), capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
             { type: 'reviewer', configFile: join(outputDir, `reviewer.${format}`), capabilities: ['code-review', 'quality-analysis', 'best-practices'], optimizations: ['incremental-analysis'] },
         ];
         const filteredAgents = focus === 'all' ? agents :

package/dist/src/cli/memory/controllers/semantic-router.js

@@ -27,43 +27,49 @@ const DEFAULT_INTENTS = [
         name: 'memory',
         category: 'storage',
         keywords: ['memory', 'store', 'retrieve', 'search', 'embedding', 'vector', 'recall', 'persist'],
-        agents: ['memory-specialist', 'swarm-memory-manager'],
+        agents: ['researcher', 'coder'],
+    },
+    {
+        name: 'frontend',
+        category: 'development',
+        keywords: ['frontend', 'ui', 'component', 'react', 'vue', 'svelte', 'css', 'tailwind', 'style', 'layout', 'accessibility', 'responsive'],
+        agents: ['frontend-dev', 'reviewer'],
+    },
+    {
+        name: 'database',
+        category: 'development',
+        keywords: ['database', 'sql', 'query', 'schema', 'migration', 'orm', 'index', 'postgres', 'mysql', 'sqlite', 'transaction'],
+        agents: ['database-dev', 'reviewer'],
     },
     {
         name: 'spell',
         category: 'workflow',
         keywords: ['spell', 'workflow', 'orchestrate', 'cast', 'pipeline', 'step'],
-        agents: ['planner', 'sparc-orchestrator'],
+        agents: ['planner'],
     },
     {
         name: 'hooks',
         category: 'automation',
         keywords: ['hook', 'pre-task', 'post-task', 'event', 'trigger', 'automation'],
-        agents: ['cicd-engineer', 'workflow-automation'],
+        agents: ['cicd-engineer', 'coder'],
     },
     {
         name: 'security',
         category: 'security',
         keywords: ['security', 'vulnerability', 'cve', 'audit', 'threat', 'permission', 'auth'],
-        agents: ['security-auditor', 'security-architect'],
-    },
-    {
-        name: 'neural',
-        category: 'ml',
-        keywords: ['neural', 'train', 'model', 'learning', 'reinforcement', 'sona', 'reasoningbank'],
-        agents: ['ml-developer', 'safla-neural'],
+        agents: ['security-auditor', 'reviewer'],
     },
     {
         name: 'test',
         category: 'quality',
         keywords: ['test', 'vitest', 'unit', 'integration', 'tdd', 'coverage', 'assertion'],
-        agents: ['tester', 'tdd-london-swarm'],
+        agents: ['tester'],
     },
     {
         name: 'github',
         category: 'integration',
         keywords: ['github', 'pr', 'pull request', 'issue', 'release', 'commit', 'branch'],
-        agents: ['pr-manager', 'github-modes', 'release-manager'],
+        agents: ['coder', 'reviewer'],
     },
 ];
 export class SemanticRouter {

package/dist/src/cli/memory/sona-optimizer.js

@@ -38,8 +38,8 @@ const AGENT_TYPES = [
     'optimizer',
     'debugger',
     'documenter',
-    'security-architect',
-    'performance-engineer',
+    'security-auditor',
+    'planner',
 ];
 /**
  * Task keywords for pattern extraction
@@ -77,13 +77,13 @@ const KEYWORD_CATEGORIES = {
         'document', 'docs', 'readme', 'comment', 'explain', 'guide',
         'tutorial', 'api-docs', 'specification', 'jsdoc',
     ],
-    'security-architect': [
+    'security-auditor': [
         'security', 'auth', 'authentication', 'authorization', 'encrypt',
         'vulnerability', 'cve', 'secure', 'permission', 'role',
     ],
-    'performance-engineer': [
-        'profiling', 'bottleneck', 'latency', 'throughput', 'cache',
-        'scale', 'load', 'stress', 'concurrent', 'parallel',
+    planner: [
+        'plan', 'breakdown', 'sequencing', 'estimate', 'milestone', 'roadmap',
+        'task', 'dependency', 'goal',
     ],
 };
 // ============================================================================

package/dist/src/cli/neural/domain/services/learning-service.js

@@ -118,9 +118,9 @@ export class LearningDomainService {
             review: 'reviewer',
             plan: 'planner',
             research: 'researcher',
-            security: 'security-architect',
-            performance: 'performance-engineer',
-            memory: 'memory-specialist',
+            security: 'security-auditor',
+            performance: 'reviewer',
+            memory: 'researcher',
         };
         for (const [keyword, role] of Object.entries(keywordMap)) {
             if (taskLower.includes(keyword)) {

package/dist/src/cli/services/agent-router.js

@@ -19,9 +19,7 @@ export const AGENT_CAPABILITIES = {
     'backend-dev': ['api', 'database', 'server', 'authentication'],
     'frontend-dev': ['ui', 'react', 'css', 'components'],
     devops: ['ci-cd', 'docker', 'deployment', 'infrastructure'],
-    'security-architect': ['security-design', 'threat-modeling', 'auth-flow'],
-    'security-auditor': ['vulnerability-scan', 'dependency-audit', 'compliance'],
-    'memory-specialist': ['memory-management', 'caching', 'persistence'],
+    'security-auditor': ['security-design', 'threat-modeling', 'auth-flow', 'vulnerability-scan', 'dependency-audit', 'compliance'],
     coordinator: ['task-distribution', 'orchestration', 'scheduling'],
     analyst: ['data-analysis', 'metrics', 'reporting', 'monitoring'],
     optimizer: ['performance', 'profiling', 'optimization', 'benchmarking'],
@@ -41,8 +39,7 @@ const TASK_PATTERNS = [
     { regex: /ui|frontend|component|react|css|style/i, agentType: 'frontend-dev' },
     { regex: /deploy|docker|ci|cd|pipeline|infrastructure/i, agentType: 'devops' },
     // Specialized patterns
-    { regex: /security|auth|permission|rbac|oauth/i, agentType: 'security-architect' },
-    { regex: /vulnerability|cve|dependency.*update|npm audit/i, agentType: 'security-auditor' },
+    { regex: /security|auth|permission|rbac|oauth|vulnerability|cve|dependency.*update|npm audit/i, agentType: 'security-auditor' },
     { regex: /performance|optimize|profile|benchmark|speed/i, agentType: 'optimizer' },
     { regex: /analyz|metric|report|monitor|dashboard/i, agentType: 'analyst' },
 ];

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)] },

package/dist/src/cli/shared/events/example-usage.js

@@ -36,20 +36,20 @@ async function main() {
     // 3. Record Agent Lifecycle Events
     // =========================================================================
     console.log('3. Recording Agent Lifecycle Events...');
-    // Agent 1: Queen Coordinator
-    await eventStore.append(createAgentSpawnedEvent('agent-1', 'queen-coordinator', 'coordination', [
+    // Agent 1: Coordinator
+    await eventStore.append(createAgentSpawnedEvent('agent-1', 'coordinator', 'coordination', [
         'orchestration',
         'task-assignment',
     ]));
     await eventStore.append(createAgentStartedEvent('agent-1'));
-    // Agent 2: Security Architect
-    await eventStore.append(createAgentSpawnedEvent('agent-2', 'security-architect', 'security', [
+    // Agent 2: Security Auditor
+    await eventStore.append(createAgentSpawnedEvent('agent-2', 'security-auditor', 'security', [
         'threat-modeling',
         'security-design',
     ]));
     await eventStore.append(createAgentStartedEvent('agent-2'));
-    // Agent 3: Core Architect
-    await eventStore.append(createAgentSpawnedEvent('agent-3', 'core-architect', 'core', ['ddd-design', 'architecture']));
+    // Agent 3: Architect
+    await eventStore.append(createAgentSpawnedEvent('agent-3', 'architect', 'core', ['ddd-design', 'architecture']));
     await eventStore.append(createAgentStartedEvent('agent-3'));
     console.log('   Agent events recorded\n');
     // =========================================================================

package/dist/src/cli/shared/hooks/task-hooks.js

@@ -144,27 +144,27 @@ export class TaskHooksManager {
             },
             {
                 keywords: ['security', 'vulnerability', 'cve', 'threat'],
-                agent: 'security-architect',
+                agent: 'security-auditor',
                 capabilities: ['security-analysis', 'vulnerability-detection', 'threat-modeling'],
             },
             {
-                keywords: ['performance', 'optimize', 'speed', 'memory'],
-                agent: 'performance-engineer',
+                keywords: ['performance', 'optimize', 'speed', 'memory', 'profile', 'benchmark'],
+                agent: 'reviewer',
                 capabilities: ['performance-optimization', 'profiling', 'benchmarking'],
             },
             {
                 keywords: ['architect', 'design', 'structure', 'pattern'],
-                agent: 'core-architect',
+                agent: 'architect',
                 capabilities: ['architecture-design', 'pattern-application', 'system-design'],
             },
             {
-                keywords: ['memory', 'storage', 'database', 'cache'],
-                agent: 'memory-specialist',
+                keywords: ['storage', 'database', 'cache', 'persistence'],
+                agent: 'researcher',
                 capabilities: ['memory-management', 'data-persistence', 'caching'],
             },
             {
-                keywords: ['swarm', 'coordinate', 'orchestrate', 'agent'],
-                agent: 'swarm-specialist',
+                keywords: ['swarm', 'coordinate', 'orchestrate', 'agent', 'hive'],
+                agent: 'coordinator',
                 capabilities: ['swarm-coordination', 'agent-orchestration', 'distributed-systems'],
             },
         ];

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.9.21';
+export const VERSION = '4.9.22';
 //# sourceMappingURL=version.js.map