@monoes/monomindcli 2.9.22 → 2.9.24

package/dist/src/mcp-tools/guidance-tools.js

@@ -6,10 +6,10 @@
  *
  * @module @monomind/cli/mcp-tools/guidance
  */
-import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { getProjectCwd } from './types.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const CLI_ROOT = join(__dirname, '../../..');
@@ -59,34 +59,90 @@ const CAPABILITY_CATALOG = {
     'agent-management': {
         name: 'Agent Management',
         description: 'Spawn, manage, and monitor individual AI agents with lifecycle control.',
-        tools: ['agent_spawn', 'agent_list', 'agent_status', 'agent_stop', 'agent_metrics', 'agent_pool', 'agent_health', 'agent_logs'],
-        commands: ['agent spawn', 'agent list', 'agent status', 'agent stop', 'agent metrics', 'agent pool', 'agent health', 'agent logs'],
+        tools: [
+            'agent_spawn',
+            'agent_list',
+            'agent_status',
+            'agent_stop',
+            'agent_metrics',
+            'agent_pool',
+            'agent_health',
+            'agent_logs',
+        ],
+        commands: [
+            'agent spawn',
+            'agent list',
+            'agent status',
+            'agent stop',
+            'agent metrics',
+            'agent pool',
+            'agent health',
+            'agent logs',
+        ],
         agents: ['coder', 'tester', 'reviewer', 'researcher', 'planner'],
         skills: [],
         whenToUse: 'When you need to create or manage individual agents for specific tasks.',
     },
-    'swarm-orchestration': {
-        name: 'Swarm Orchestration',
-        description: 'Multi-agent coordination with topology-aware communication and consensus.',
-        tools: ['swarm_init', 'swarm_status', 'swarm_spawn', 'swarm_terminate', 'swarm_topology', 'swarm_metrics'],
-        commands: ['swarm init', 'swarm status', 'swarm spawn', 'swarm terminate'],
-        agents: ['coordinator', 'mesh-coordinator', 'collective-intelligence-coordinator'],
-        skills: ['swarm-orchestration', 'swarm-advanced', 'monomind-swarm'],
-        whenToUse: 'When a task requires multiple agents working together (3+ files, features, refactoring).',
+    monoswarm: {
+        name: 'Monoswarm Coordination',
+        description: 'Multi-agent coordination and vote arbitration: topology/roster bookkeeping in a JSON state file, threshold-based voting (majority/supermajority/unanimous/threshold).',
+        tools: [
+            'monoswarm_init',
+            'monoswarm_status',
+            'monoswarm_scale',
+            'monoswarm_health',
+            'monoswarm_shutdown',
+            'monoswarm_agent_add',
+            'monoswarm_vote',
+        ],
+        commands: ['monoswarm init', 'monoswarm status', 'monoswarm scale', 'monoswarm stop'],
+        agents: [
+            'coordinator',
+            'mesh-coordinator',
+            'collective-intelligence-coordinator',
+            'quorum-manager',
+        ],
+        skills: ['monoswarm'],
+        whenToUse: 'When a task requires multiple agents working together (3+ files, features, refactoring), or agents need to vote on a decision.',
     },
     'memory-knowledge': {
         name: 'Memory & Knowledge',
         description: 'Persistent memory with ANN vector search, SQLite storage, and embeddings.',
-        tools: ['memory_store', 'memory_retrieve', 'memory_search', 'memory_list', 'memory_delete', 'memory_init', 'memory_export', 'memory_import', 'memory_stats', 'memory_compact', 'memory_namespace'],
-        commands: ['memory store', 'memory retrieve', 'memory search', 'memory list', 'memory delete', 'memory init'],
-        agents: ['swarm-memory-manager'],
+        tools: [
+            'memory_pattern-store',
+            'memory_hierarchical-store',
+            'memory_pattern-search',
+            'memory_hierarchical-recall',
+            'memory_kg_ingest',
+            'memory_kg_search',
+            'memory_kg_stats',
+            'memory_kg_consolidate',
+            'memory_kg_rollback',
+            'memory_batch',
+            'memory_health',
+        ],
+        commands: [
+            'memory store',
+            'memory retrieve',
+            'memory search',
+            'memory list',
+            'memory delete',
+            'memory init',
+        ],
+        agents: ['monoswarm-memory-manager'],
         skills: ['memory-advanced', 'memory-vector-search', 'memory-patterns', 'memory-learning'],
         whenToUse: 'When you need to persist, search, or retrieve knowledge across sessions.',
     },
     'intelligence-learning': {
         name: 'Intelligence & Learning',
         description: 'Pattern storage and cosine-similarity search (SONA/ReasoningBank) backed by real embeddings.',
-        tools: ['neural_train', 'neural_predict', 'neural_status', 'neural_patterns', 'neural_optimize'],
+        tools: [
+            'neural_train',
+            'neural_predict',
+            'neural_status',
+            'neural_patterns',
+            'neural_optimize',
+        ],
         commands: [],
         agents: [],
         skills: ['reasoningbank-intelligence', 'memory-reasoningbank'],
@@ -95,41 +151,80 @@ const CAPABILITY_CATALOG = {
     'hooks-automation': {
         name: 'Hooks & Automation',
         description: '17 lifecycle hooks + 12 background workers for automated learning and coordination.',
-        tools: ['hooks_pre_task', 'hooks_post_task', 'hooks_pre_edit', 'hooks_post_edit', 'hooks_route', 'hooks_explain'],
+        tools: [
+            'hooks_pre_task',
+            'hooks_post_task',
+            'hooks_pre_edit',
+            'hooks_post_edit',
+            'hooks_route',
+            'hooks_explain',
+        ],
         commands: [
-            'hooks pre-task', 'hooks post-task', 'hooks pre-edit', 'hooks post-edit',
-            'hooks session-start', 'hooks session-end', 'hooks route', 'hooks explain',
-            'hooks pretrain', 'hooks build-agents', 'hooks intelligence', 'hooks worker',
-            'hooks coverage-gaps', 'hooks coverage-route', 'hooks coverage-suggest',
-            'hooks statusline', 'hooks progress',
+            'hooks pre-task',
+            'hooks post-task',
+            'hooks pre-edit',
+            'hooks post-edit',
+            'hooks session-start',
+            'hooks session-end',
+            'hooks route',
+            'hooks explain',
+            'hooks pretrain',
+            'hooks intelligence',
+            'hooks worker',
+            'hooks coverage-gaps',
+            'hooks coverage-route',
+            'hooks coverage-suggest',
+            'hooks statusline',
+            'hooks progress',
         ],
         agents: [],
         skills: ['hooks-automation'],
         whenToUse: 'When you need pre/post task hooks, background workers, coverage routing, or intelligence.',
     },
-    'hive-mind': {
-        name: 'Hive Mind Consensus',
-        description: 'Queen-led Byzantine fault-tolerant distributed consensus with multiple strategies.',
-        tools: ['hive_mind_init', 'hive_mind_status', 'hive_mind_propose', 'hive_mind_vote', 'hive_mind_consensus', 'hive_mind_metrics'],
-        commands: ['hive-mind init', 'hive-mind status', 'hive-mind consensus', 'hive-mind sessions', 'hive-mind spawn', 'hive-mind stop'],
-        agents: ['crdt-synchronizer', 'quorum-manager'],
-        skills: ['hive-mind-advanced'],
-        whenToUse: 'When multiple agents need to reach agreement on decisions using BFT, Raft, or CRDT.',
-    },
-    'security': {
+    security: {
         name: 'Security & Compliance',
         description: 'Security scanning, CVE remediation, input validation, claims-based authorization.',
-        tools: ['security_scan', 'security_audit', 'security_cve', 'security_threats', 'security_validate', 'security_report', 'claims_check', 'claims_grant', 'claims_revoke', 'claims_list'],
-        commands: ['security scan', 'security audit', 'security cve', 'security threats', 'claims check', 'claims grant'],
+        tools: [
+            'security_scan',
+            'security_audit',
+            'security_cve',
+            'security_threats',
+            'security_validate',
+            'security_report',
+            'claims_check',
+            'claims_grant',
+            'claims_revoke',
+            'claims_list',
+        ],
+        commands: [
+            'security scan',
+            'security audit',
+            'security cve',
+            'security threats',
+            'claims check',
+            'claims grant',
+        ],
         agents: ['security-manager'],
         skills: [],
         whenToUse: 'When auditing code for vulnerabilities, managing permissions, or security reviews.',
     },
-    'performance': {
+    performance: {
         name: 'Performance & Profiling',
         description: 'Benchmarking, profiling, metrics collection, and optimization recommendations.',
-        tools: ['performance_benchmark', 'performance_profile', 'performance_metrics', 'performance_optimize', 'performance_report'],
-        commands: ['performance benchmark', 'performance profile', 'performance metrics', 'performance optimize', 'performance report'],
+        tools: [
+            'performance_benchmark',
+            'performance_profile',
+            'performance_metrics',
+            'performance_optimize',
+            'performance_report',
+        ],
+        commands: [
+            'performance benchmark',
+            'performance profile',
+            'performance metrics',
+            'performance optimize',
+            'performance report',
+        ],
         agents: [],
         skills: ['performance-analysis'],
         whenToUse: 'When measuring, profiling, or optimizing system performance.',
@@ -137,16 +232,50 @@ const CAPABILITY_CATALOG = {
     'github-integration': {
         name: 'GitHub Integration',
         description: 'PR management, code review, issue tracking, release automation, multi-repo coordination.',
-        tools: ['github_pr_manage', 'github_code_review', 'github_issue_track', 'github_repo_analyze', 'github_sync_coord', 'github_metrics'],
+        tools: [
+            'github_pr_manage',
+            'github_code_review',
+            'github_issue_track',
+            'github_repo_analyze',
+            'github_sync_coord',
+            'github_metrics',
+        ],
         commands: [],
-        agents: ['pr-manager', 'code-review-swarm', 'issue-tracker', 'release-manager', 'repo-architect', 'workflow-automation', 'multi-repo-swarm', 'project-board-sync', 'swarm-pr', 'swarm-issue', 'sync-coordinator', 'github-modes'],
-        skills: ['github-release-management', 'github-workflow-automation', 'github-code-review', 'github-project-management', 'github-multi-repo'],
+        agents: [
+            'pr-manager',
+            'code-review-swarm',
+            'issue-tracker',
+            'release-manager',
+            'repo-architect',
+            'workflow-automation',
+            'multi-repo-swarm',
+            'project-board-sync',
+            'swarm-pr',
+            'swarm-issue',
+            'sync-coordinator',
+            'github-modes',
+        ],
+        skills: [
+            'github-release-management',
+            'github-workflow-automation',
+            'github-code-review',
+            'github-project-management',
+            'github-multi-repo',
+        ],
         whenToUse: 'When working with GitHub repos, PRs, issues, releases, or CI/CD pipelines.',
     },
     'session-workflow': {
         name: 'Session & Tasks',
         description: 'Session state management and task lifecycle.',
-        tools: ['session_start', 'session_end', 'session_restore', 'session_list', 'task_create', 'task_assign', 'task_status'],
+        tools: [
+            'session_start',
+            'session_end',
+            'session_restore',
+            'session_list',
+            'task_create',
+            'task_assign',
+            'task_status',
+        ],
         commands: ['session start', 'session end', 'session restore', 'task create'],
         agents: [],
         skills: [],
@@ -174,45 +303,128 @@ const CAPABILITY_CATALOG = {
         name: 'Configuration & System',
         description: 'Configuration management, provider setup, system diagnostics, shell completions.',
         tools: ['config_get', 'config_set', 'config_list', 'config_provider'],
-        commands: ['config get', 'config set', 'config list', 'config provider', 'doctor', 'status', 'providers list', 'completions'],
+        commands: [
+            'config get',
+            'config set',
+            'config list',
+            'config provider',
+            'doctor',
+            'status',
+            'providers list',
+            'completions',
+        ],
         agents: [],
         skills: [],
         whenToUse: 'When managing configuration, providers, or running diagnostics.',
     },
 };
 const TASK_ROUTES = [
-    { pattern: /\b(bug|fix|debug|error|issue|crash|broken)\b/i, areas: ['agent-management', 'hooks-automation'], workflow: 'bugfix' },
-    { pattern: /\b(feature|implement|create|build|add)\b/i, areas: ['swarm-orchestration', 'agent-management', 'hooks-automation'], workflow: 'feature' },
-    { pattern: /\b(refactor|restructure|reorganize|clean\s*up|modernize)\b/i, areas: ['swarm-orchestration', 'code-analysis'], workflow: 'refactor' },
-    { pattern: /\b(test|coverage|tdd|spec|assert)\b/i, areas: ['agent-management', 'hooks-automation', 'code-analysis'], workflow: 'testing' },
-    { pattern: /\b(security|vulnerab|cve|audit|threat|auth)\b/i, areas: ['security'], workflow: 'security' },
-    { pattern: /\b(perf|benchmark|profil|slow|optimi|latency|speed)\b/i, areas: ['performance'], workflow: 'performance' },
-    { pattern: /\b(memory|embed|vector|search|hnsw|semantic)\b/i, areas: ['memory-knowledge', 'embeddings-vectors'], workflow: 'memory' },
-    { pattern: /\b(pr|pull\s*request|review|merge|branch)\b/i, areas: ['github-integration'], workflow: 'github-pr' },
-    { pattern: /\b(release|deploy|publish|version|changelog)\b/i, areas: ['github-integration', 'session-workflow'], workflow: 'release' },
-    { pattern: /\b(swarm|multi.agent|coordin|hive|consensus)\b/i, areas: ['swarm-orchestration', 'hive-mind'], workflow: 'swarm' },
-    { pattern: /\b(learn|train|neural|pattern|sona|lora)\b/i, areas: ['intelligence-learning'], workflow: 'learning' },
-    { pattern: /\b(hook|pre.task|post.task|worker)\b/i, areas: ['hooks-automation', 'session-workflow'], workflow: 'automation' },
-    { pattern: /\b(config|setup|init|provider|doctor)\b/i, areas: ['config-system'], workflow: 'setup' },
+    {
+        pattern: /\b(bug|fix|debug|error|issue|crash|broken)\b/i,
+        areas: ['agent-management', 'hooks-automation'],
+        workflow: 'bugfix',
+    },
+    {
+        pattern: /\b(feature|implement|create|build|add)\b/i,
+        areas: ['monoswarm', 'agent-management', 'hooks-automation'],
+        workflow: 'feature',
+    },
+    {
+        pattern: /\b(refactor|restructure|reorganize|clean\s*up|modernize)\b/i,
+        areas: ['monoswarm', 'code-analysis'],
+        workflow: 'refactor',
+    },
+    {
+        pattern: /\b(test|coverage|tdd|spec|assert)\b/i,
+        areas: ['agent-management', 'hooks-automation', 'code-analysis'],
+        workflow: 'testing',
+    },
+    {
+        pattern: /\b(security|vulnerab|cve|audit|threat|auth)\b/i,
+        areas: ['security'],
+        workflow: 'security',
+    },
+    {
+        pattern: /\b(perf|benchmark|profil|slow|optimi|latency|speed)\b/i,
+        areas: ['performance'],
+        workflow: 'performance',
+    },
+    {
+        pattern: /\b(memory|embed|vector|search|hnsw|semantic)\b/i,
+        areas: ['memory-knowledge', 'embeddings-vectors'],
+        workflow: 'memory',
+    },
+    {
+        pattern: /\b(pr|pull\s*request|review|merge|branch)\b/i,
+        areas: ['github-integration'],
+        workflow: 'github-pr',
+    },
+    {
+        pattern: /\b(release|deploy|publish|version|changelog)\b/i,
+        areas: ['github-integration', 'session-workflow'],
+        workflow: 'release',
+    },
+    {
+        pattern: /\b(swarm|multi.agent|coordin|hive|consensus)\b/i,
+        areas: ['monoswarm'],
+        workflow: 'swarm',
+    },
+    {
+        pattern: /\b(learn|train|neural|pattern|sona|lora)\b/i,
+        areas: ['intelligence-learning'],
+        workflow: 'learning',
+    },
+    {
+        pattern: /\b(hook|pre.task|post.task|worker)\b/i,
+        areas: ['hooks-automation', 'session-workflow'],
+        workflow: 'automation',
+    },
+    {
+        pattern: /\b(config|setup|init|provider|doctor)\b/i,
+        areas: ['config-system'],
+        workflow: 'setup',
+    },
 ];
 const WORKFLOW_TEMPLATES = {
     bugfix: {
-        steps: ['Research the bug (hooks route)', 'Reproduce with tests', 'Fix the code', 'Verify fix passes', 'Record outcome (hooks post-task)'],
+        steps: [
+            'Research the bug (hooks route)',
+            'Reproduce with tests',
+            'Fix the code',
+            'Verify fix passes',
+            'Record outcome (hooks post-task)',
+        ],
         agents: ['researcher', 'coder', 'tester'],
         topology: 'hierarchical',
     },
     feature: {
-        steps: ['Design architecture', 'Implement solution', 'Write tests', 'Review code', 'Record patterns (hooks post-task)'],
+        steps: [
+            'Design architecture',
+            'Implement solution',
+            'Write tests',
+            'Review code',
+            'Record patterns (hooks post-task)',
+        ],
         agents: ['planner', 'coder', 'tester', 'reviewer'],
         topology: 'hierarchical',
     },
     refactor: {
-        steps: ['Analyze code structure', 'Plan refactor approach', 'Implement changes', 'Verify no regressions'],
+        steps: [
+            'Analyze code structure',
+            'Plan refactor approach',
+            'Implement changes',
+            'Verify no regressions',
+        ],
         agents: ['coder', 'reviewer'],
         topology: 'hierarchical',
     },
     testing: {
-        steps: ['Analyze coverage gaps', 'Generate test plan', 'Write tests', 'Verify coverage improvement'],
+        steps: [
+            'Analyze coverage gaps',
+            'Generate test plan',
+            'Write tests',
+            'Verify coverage improvement',
+        ],
         agents: ['tester', 'coder'],
         topology: 'hierarchical',
     },
@@ -227,32 +439,64 @@ const WORKFLOW_TEMPLATES = {
         topology: 'hierarchical',
     },
     memory: {
-        steps: ['Initialize memory store', 'Store/retrieve patterns', 'Search with HNSW', 'Compact and optimize'],
-        agents: ['swarm-memory-manager'],
+        steps: [
+            'Initialize memory store',
+            'Store/retrieve patterns',
+            'Search with HNSW',
+            'Compact and optimize',
+        ],
+        agents: ['monoswarm-memory-manager'],
         topology: 'hierarchical',
     },
     'github-pr': {
-        steps: ['Analyze changes', 'Run code review swarm', 'Check CI status', 'Merge or request changes'],
+        steps: [
+            'Analyze changes',
+            'Run code review swarm',
+            'Check CI status',
+            'Merge or request changes',
+        ],
         agents: ['pr-manager', 'code-review-swarm', 'reviewer'],
         topology: 'hierarchical',
     },
     release: {
-        steps: ['Verify all tests pass', 'Generate changelog', 'Bump version', 'Publish packages', 'Create GitHub release'],
+        steps: [
+            'Verify all tests pass',
+            'Generate changelog',
+            'Bump version',
+            'Publish packages',
+            'Create GitHub release',
+        ],
         agents: ['release-manager', 'tester'],
         topology: 'hierarchical',
     },
     swarm: {
-        steps: ['Initialize swarm topology', 'Spawn specialized agents', 'Coordinate via memory', 'Collect and synthesize results'],
+        steps: [
+            'Initialize swarm topology',
+            'Spawn specialized agents',
+            'Coordinate via memory',
+            'Collect and synthesize results',
+        ],
         agents: ['mesh-coordinator', 'coder', 'tester', 'reviewer'],
         topology: 'hierarchical',
     },
     learning: {
-        steps: ['Pretrain on codebase', 'Record trajectories', 'Compute rewards', 'Distill learning', 'Consolidate (EWC++)'],
+        steps: [
+            'Pretrain on codebase',
+            'Record trajectories',
+            'Compute rewards',
+            'Distill learning',
+            'Consolidate (EWC++)',
+        ],
         agents: [],
         topology: 'hierarchical',
     },
     automation: {
-        steps: ['List available hooks/workers', 'Configure hook handlers', 'Dispatch workers', 'Monitor outcomes'],
+        steps: [
+            'List available hooks/workers',
+            'Configure hook handlers',
+            'Dispatch workers',
+            'Monitor outcomes',
+        ],
         agents: [],
         topology: 'hierarchical',
     },
@@ -288,7 +532,9 @@ function discoverAgents() {
                 if (entry.isDirectory()) {
                     walk(full, depth + 1);
                 }
-                else if (entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'MIGRATION_SUMMARY.md') {
+                else if (entry.isFile() &&
+                    entry.name.endsWith('.md') &&
+                    entry.name !== 'MIGRATION_SUMMARY.md') {
                     if (statSync(full).size > 512 * 1024)
                         continue; // skip files > 512 KB
                     const content = readFileSync(full, 'utf-8');
@@ -298,7 +544,9 @@ function discoverAgents() {
                 }
             }
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     walk(agentsDir, 0);
     return [...new Set(agents)].sort();
@@ -321,7 +569,9 @@ function discoverSkills() {
             }
         }
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     return skills.sort();
 }
 // ── MCP Tool Definitions ────────────────────────────────────
@@ -333,7 +583,7 @@ const guidanceCapabilities = {
         properties: {
             area: {
                 type: 'string',
-                description: 'Filter to a specific area (e.g., "swarm-orchestration", "memory-knowledge"). Omit to list all areas.',
+                description: 'Filter to a specific area (e.g., "monoswarm", "memory-knowledge"). Omit to list all areas.',
             },
             format: {
                 type: 'string',
@@ -354,7 +604,15 @@ const guidanceCapabilities = {
             const cap = CAPABILITY_CATALOG[area];
             if (!cap) {
                 const available = Object.keys(CAPABILITY_CATALOG).join(', ');
-                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Unknown capability area', available }, null, 2) }], isError: true };
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ error: 'Unknown capability area', available }, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
             }
             return { content: [{ type: 'text', text: JSON.stringify(cap, null, 2) }] };
         }
@@ -370,7 +628,14 @@ const guidanceCapabilities = {
             skillCount: val.skills.length,
             whenToUse: val.whenToUse,
         }));
-        return { content: [{ type: 'text', text: JSON.stringify({ areas: summary, totalAreas: summary.length }, null, 2) }] };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ areas: summary, totalAreas: summary.length }, null, 2),
+                },
+            ],
+        };
     },
 };
 const guidanceRecommend = {
@@ -417,29 +682,32 @@ const guidanceRecommend = {
         const recommendations = [...seen.values()];
         if (recommendations.length === 0) {
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: JSON.stringify({
                             task,
                             message: 'No specific pattern matched. Here are general-purpose capabilities:',
                             suggestions: [
                                 { area: 'agent-management', reason: 'Spawn individual agents for targeted work' },
-                                { area: 'swarm-orchestration', reason: 'Use swarms for multi-file or complex tasks' },
+                                { area: 'monoswarm', reason: 'Use swarms for multi-file or complex tasks' },
                                 { area: 'hooks-automation', reason: 'Use hooks for task routing and learning' },
                             ],
                             tip: 'Use guidance_capabilities for a full list of all capability areas.',
                         }, null, 2),
-                    }],
+                    },
+                ],
             };
         }
         const primaryWorkflow = recommendations[0]?.workflow;
         const template = primaryWorkflow ? WORKFLOW_TEMPLATES[primaryWorkflow] : undefined;
         return {
-            content: [{
+            content: [
+                {
                     type: 'text',
                     text: JSON.stringify({
                         task,
-                        recommendations: recommendations.map(r => ({
+                        recommendations: recommendations.map((r) => ({
                             area: r.area,
                             name: r.capability.name,
                             description: r.capability.description,
@@ -447,14 +715,17 @@ const guidanceRecommend = {
                             agents: r.capability.agents,
                             skills: r.capability.skills,
                         })),
-                        workflow: template ? {
-                            name: primaryWorkflow,
-                            steps: template.steps,
-                            agents: template.agents,
-                            topology: template.topology,
-                        } : undefined,
+                        workflow: template
+                            ? {
+                                name: primaryWorkflow,
+                                steps: template.steps,
+                                agents: template.agents,
+                                topology: template.topology,
+                            }
+                            : undefined,
                     }, null, 2),
-                }],
+                },
+            ],
         };
     },
 };
@@ -494,7 +765,7 @@ const guidanceWorkflow = {
             type: {
                 type: 'string',
                 enum: Object.keys(WORKFLOW_TEMPLATES),
-                description: 'Workflow type. Options: ' + Object.keys(WORKFLOW_TEMPLATES).join(', '),
+                description: `Workflow type. Options: ${Object.keys(WORKFLOW_TEMPLATES).join(', ')}`,
             },
         },
         required: ['type'],
@@ -508,18 +779,21 @@ const guidanceWorkflow = {
         const template = type ? WORKFLOW_TEMPLATES[type] : undefined;
         if (!template) {
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: JSON.stringify({
                             error: 'Unknown workflow type',
                             available: Object.keys(WORKFLOW_TEMPLATES),
                         }, null, 2),
-                    }],
+                    },
+                ],
                 isError: true,
             };
         }
         return {
-            content: [{
+            content: [
+                {
                     type: 'text',
                     text: JSON.stringify({
                         workflow: type,
@@ -528,10 +802,11 @@ const guidanceWorkflow = {
                             topology: template.topology,
                             maxAgents: Math.max(template.agents.length + 1, 4),
                             strategy: 'specialized',
-                            consensus: 'raft',
+                            consensus: 'majority',
                         },
                     }, null, 2),
-                }],
+                },
+            ],
         };
     },
 };
@@ -543,7 +818,14 @@ const guidanceQuickRef = {
         properties: {
             domain: {
                 type: 'string',
-                enum: ['getting-started', 'daily-dev', 'swarm-ops', 'memory-ops', 'github-ops', 'diagnostics'],
+                enum: [
+                    'getting-started',
+                    'daily-dev',
+                    'swarm-ops',
+                    'memory-ops',
+                    'github-ops',
+                    'diagnostics',
+                ],
                 description: 'Domain to get quick reference for.',
             },
         },
@@ -559,63 +841,127 @@ const guidanceQuickRef = {
             'getting-started': {
                 title: 'Getting Started',
                 commands: [
-                    { cmd: 'npx monomind@latest init --wizard', desc: 'Initialize project with interactive setup' },
-                    { cmd: 'npx monomind@latest doctor --fix', desc: 'Run diagnostics and auto-fix issues' },
+                    {
+                        cmd: 'npx monomind@latest init --wizard',
+                        desc: 'Initialize project with interactive setup',
+                    },
+                    {
+                        cmd: 'npx monomind@latest doctor --fix',
+                        desc: 'Run diagnostics and auto-fix issues',
+                    },
                     { cmd: 'npx monomind@latest status', desc: 'Check system status' },
                 ],
             },
             'daily-dev': {
                 title: 'Daily Development',
                 commands: [
-                    { cmd: 'npx monomind@latest hooks pre-task --description "..."', desc: 'Get routing recommendation before task' },
-                    { cmd: 'npx monomind@latest hooks post-task --task-id "..." --success true', desc: 'Record task outcome for learning' },
-                    { cmd: 'npx monomind@latest hooks post-edit --file "..." --train-neural true', desc: 'Train patterns from edits' },
-                    { cmd: 'npx monomind@latest memory search --query "..."', desc: 'Search memory for relevant patterns' },
-                    { cmd: 'npx monomind@latest hooks route --task "..."', desc: 'Route task to optimal agent' },
+                    {
+                        cmd: 'npx monomind@latest hooks pre-task --description "..."',
+                        desc: 'Get routing recommendation before task',
+                    },
+                    {
+                        cmd: 'npx monomind@latest hooks post-task --task-id "..." --success true',
+                        desc: 'Record task outcome for learning',
+                    },
+                    {
+                        cmd: 'npx monomind@latest hooks post-edit --file "..." --train-neural true',
+                        desc: 'Train patterns from edits',
+                    },
+                    {
+                        cmd: 'npx monomind@latest memory search --query "..."',
+                        desc: 'Search memory for relevant patterns',
+                    },
+                    {
+                        cmd: 'npx monomind@latest hooks route --task "..."',
+                        desc: 'Route task to optimal agent',
+                    },
                 ],
             },
             'swarm-ops': {
-                title: 'Swarm Operations',
+                title: 'Monoswarm Operations',
                 commands: [
-                    { cmd: 'npx monomind@latest swarm init --topology hierarchical --max-agents 8', desc: 'Initialize anti-drift swarm' },
-                    { cmd: 'npx monomind@latest swarm status', desc: 'Check swarm status' },
-                    { cmd: 'npx monomind@latest agent spawn -t coder --name my-coder', desc: 'Spawn a specific agent' },
-                    { cmd: 'npx monomind@latest hive-mind init --strategy byzantine', desc: 'Start hive-mind consensus' },
+                    {
+                        cmd: 'npx monomind@latest monoswarm init --topology hierarchical --max-agents 8',
+                        desc: 'Initialize anti-drift monoswarm',
+                    },
+                    { cmd: 'npx monomind@latest monoswarm status', desc: 'Check monoswarm status' },
+                    {
+                        cmd: 'npx monomind@latest agent spawn -t coder --name my-coder',
+                        desc: 'Spawn a specific agent',
+                    },
                 ],
             },
             'memory-ops': {
                 title: 'Memory Operations',
                 commands: [
                     { cmd: 'npx monomind@latest memory init --force', desc: 'Initialize memory database' },
-                    { cmd: 'npx monomind@latest memory store --key "k" --value "v" --namespace patterns', desc: 'Store a value' },
-                    { cmd: 'npx monomind@latest memory search --query "auth patterns"', desc: 'Semantic vector search' },
-                    { cmd: 'npx monomind@latest memory list --namespace patterns', desc: 'List entries in namespace' },
-                    { cmd: 'npx monomind@latest memory retrieve --key "k" --namespace patterns', desc: 'Get a specific entry' },
+                    {
+                        cmd: 'npx monomind@latest memory store --key "k" --value "v" --namespace patterns',
+                        desc: 'Store a value',
+                    },
+                    {
+                        cmd: 'npx monomind@latest memory search --query "auth patterns"',
+                        desc: 'Semantic vector search',
+                    },
+                    {
+                        cmd: 'npx monomind@latest memory list --namespace patterns',
+                        desc: 'List entries in namespace',
+                    },
+                    {
+                        cmd: 'npx monomind@latest memory retrieve --key "k" --namespace patterns',
+                        desc: 'Get a specific entry',
+                    },
                 ],
             },
             'github-ops': {
                 title: 'GitHub Operations',
                 commands: [
-                    { cmd: 'Use pr-manager agent for PR lifecycle', desc: 'Spawn pr-manager for automated PR management' },
-                    { cmd: 'Use code-review-swarm agent for reviews', desc: 'Deploy multi-agent code review' },
-                    { cmd: 'Use release-manager agent for releases', desc: 'Automated release with changelog' },
+                    {
+                        cmd: 'Use pr-manager agent for PR lifecycle',
+                        desc: 'Spawn pr-manager for automated PR management',
+                    },
+                    {
+                        cmd: 'Use code-review-swarm agent for reviews',
+                        desc: 'Deploy multi-agent code review',
+                    },
+                    {
+                        cmd: 'Use release-manager agent for releases',
+                        desc: 'Automated release with changelog',
+                    },
                     { cmd: 'Use issue-tracker agent for triage', desc: 'Intelligent issue management' },
                 ],
             },
             diagnostics: {
                 title: 'Diagnostics & Troubleshooting',
                 commands: [
-                    { cmd: 'npx monomind@latest doctor --fix', desc: 'Full system diagnostics with auto-fix' },
+                    {
+                        cmd: 'npx monomind@latest doctor --fix',
+                        desc: 'Full system diagnostics with auto-fix',
+                    },
                     { cmd: 'npx monomind@latest status --watch', desc: 'Live system monitoring' },
                     { cmd: 'npx monomind@latest hooks worker status', desc: 'Background worker health' },
-                    { cmd: 'npx monomind@latest performance benchmark --suite all', desc: 'Run all benchmarks' },
-                    { cmd: 'npx monomind@latest hooks progress --detailed', desc: 'V1 implementation progress' },
+                    {
+                        cmd: 'npx monomind@latest performance benchmark --suite all',
+                        desc: 'Run all benchmarks',
+                    },
+                    {
+                        cmd: 'npx monomind@latest hooks progress --detailed',
+                        desc: 'V1 implementation progress',
+                    },
                 ],
             },
         };
         const ref = domain ? refs[domain] : undefined;
         if (!ref) {
-            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Unknown quick-ref domain', available: Object.keys(refs) }, null, 2) }], isError: true };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ error: 'Unknown quick-ref domain', available: Object.keys(refs) }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
         }
         return { content: [{ type: 'text', text: JSON.stringify(ref, null, 2) }] };
     },