agentic-flow 2.0.7 → 3.0.0-alpha.2

package/dist/agentic-flow/src/mcp/fastmcp/servers/stdio-full.js

@@ -0,0 +1,836 @@
+#!/usr/bin/env node
+// Full FastMCP server with stdio transport - All 86 claude-flow-sdk tools
+import { FastMCP } from 'fastmcp';
+import { z } from 'zod';
+import { execSync } from 'child_process';
+import { AgentDBService } from '../../../services/agentdb-service.js';
+import { registerSessionTools } from '../tools/session-tools.js';
+import { registerGitHubTools } from '../tools/github-tools.js';
+import { registerNeuralTools } from '../tools/neural-tools.js';
+import { registerRuVectorTools } from '../tools/ruvector-tools.js';
+import { registerSonaRvfTools } from '../tools/sona-rvf-tools.js';
+import { registerInfrastructureTools } from '../tools/infrastructure-tools.js';
+import { registerAutopilotTools } from '../tools/autopilot-tools.js';
+import { registerPerformanceTools } from '../tools/performance-tools.js';
+import { registerWorkflowTools } from '../tools/workflow-tools.js';
+import { registerDAATools } from '../tools/daa-tools.js';
+import { registerAttentionTools } from '../tools/attention-tools.js';
+import { registerHiddenControllerTools } from '../tools/hidden-controllers.js';
+import { registerQUICTools } from '../tools/quic-tools.js';
+import { registerRVFTools } from '../tools/rvf-tools.js';
+import { registerCostOptimizerTools } from '../tools/cost-optimizer-tools.js';
+import { registerStreamingTools } from '../tools/streaming-tools.js';
+import { registerSonaTools } from '../tools/sona-tools.js';
+import { registerMemoryTools } from '../tools/memory-tools.js';
+import { registerQuantizationTools } from '../tools/quantization-tools.js';
+import { registerExplainabilityTools } from '../tools/explainability-tools.js';
+// SECURITY: Import rate limiting middleware
+import { withRateLimit } from '../../middleware/apply-rate-limit.js';
+// Import DirectCallBridge to eliminate CLI spawning
+import { DirectCallBridge } from '../../../services/direct-call-bridge.js';
+import { SwarmService } from '../../../services/swarm-service.js';
+import { HookService } from '../../../services/hook-service.js';
+console.error('Starting FastMCP Full Server (stdio transport)...');
+console.error('Loading 211+ tools: core (12), agentdb (12), session (8), github (8), neural (6), ruvector (6), sona-rvf (11), infrastructure (13), autopilot (10), performance (15), workflow (11), daa (10), attention (6), hidden-controllers (17), quic (4), rvf (5), cost-optimizer (4), streaming (10), sona-rl (8), memory (6), quantization (8), explainability (10)');
+console.error('SECURITY: Rate limiting enabled (100 req/min default, 10 req/min for critical tools)');
+// Create server
+const server = new FastMCP({
+    name: 'fastmcp-stdio-full',
+    version: '1.0.0'
+});
+// Initialize DirectCallBridge (eliminates CLI spawning anti-pattern)
+let directBridge = null;
+(async () => {
+    try {
+        const agentDB = await AgentDBService.getInstance();
+        const hooks = new HookService(agentDB);
+        const swarm = new SwarmService(hooks, agentDB);
+        directBridge = new DirectCallBridge(agentDB, swarm);
+        console.error('[DirectCallBridge] Initialized (100-200x faster than CLI spawning)');
+    }
+    catch (err) {
+        console.error('[DirectCallBridge] Initialization failed, tools will fall back to CLI:', err);
+    }
+})();
+// SECURITY: Wrap addTool to automatically apply rate limiting to ALL tools
+const originalAddTool = server.addTool.bind(server);
+server.addTool = function (tool) {
+    const wrappedTool = {
+        ...tool,
+        execute: withRateLimit(tool.name, tool.execute)
+    };
+    return originalAddTool(wrappedTool);
+};
+// Tool 1: Memory Store
+server.addTool({
+    name: 'memory_store',
+    description: 'Store a value in persistent memory with optional namespace and TTL',
+    parameters: z.object({
+        key: z.string().min(1).describe('Memory key'),
+        value: z.string().describe('Value to store'),
+        namespace: z.string().optional().default('default').describe('Memory namespace'),
+        ttl: z.number().positive().optional().describe('Time-to-live in seconds')
+    }),
+    execute: async ({ key, value, namespace, ttl }) => {
+        try {
+            const cmd = [
+                'npx claude-flow@alpha memory store',
+                `"${key}"`,
+                `"${value}"`,
+                `--namespace "${namespace}"`,
+                ttl ? `--ttl ${ttl}` : ''
+            ].filter(Boolean).join(' ');
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            return JSON.stringify({
+                success: true,
+                key,
+                namespace,
+                size: value.length,
+                ttl,
+                timestamp: new Date().toISOString(),
+                message: 'Memory stored successfully'
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to store memory: ${error.message}`);
+        }
+    }
+});
+// Tool 2: Memory Retrieve
+server.addTool({
+    name: 'memory_retrieve',
+    description: 'Retrieve a value from persistent memory',
+    parameters: z.object({
+        key: z.string().min(1).describe('Memory key'),
+        namespace: z.string().optional().default('default').describe('Memory namespace')
+    }),
+    execute: async ({ key, namespace }) => {
+        try {
+            const cmd = `npx claude-flow@alpha memory retrieve "${key}" --namespace "${namespace}"`;
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            return JSON.stringify({
+                success: true,
+                key,
+                namespace,
+                value: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to retrieve memory: ${error.message}`);
+        }
+    }
+});
+// Tool 3: Memory Search
+server.addTool({
+    name: 'memory_search',
+    description: 'Search for keys matching a pattern in memory with wildcard support',
+    parameters: z.object({
+        pattern: z.string().min(1).describe('Search pattern (supports wildcards like * and ?)'),
+        namespace: z.string().optional().describe('Memory namespace to search in (searches all if not specified)'),
+        limit: z.number().positive().optional().default(10).describe('Maximum number of results to return (1-100)')
+            .refine((val) => val >= 1 && val <= 100, { message: 'Limit must be between 1 and 100' })
+    }),
+    execute: async ({ pattern, namespace, limit }) => {
+        try {
+            const cmd = [
+                'npx claude-flow@alpha memory search',
+                `"${pattern}"`,
+                namespace ? `--namespace "${namespace}"` : '',
+                `--limit ${limit}`
+            ].filter(Boolean).join(' ');
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            return JSON.stringify({
+                success: true,
+                pattern,
+                namespace: namespace || 'all',
+                limit,
+                results: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to search memory: ${error.message}`);
+        }
+    }
+});
+// Tool: Memory Synthesize - Context synthesis from memory search results
+server.addTool({
+    name: 'memory_synthesize',
+    description: 'Search memory and synthesize a coherent context summary with patterns, insights, and recommendations from retrieved episodes',
+    parameters: z.object({
+        query: z.string().min(1).describe('Search query for finding relevant memories'),
+        limit: z.number().min(1).max(50).optional().default(10).describe('Number of memories to synthesize (1-50)'),
+        namespace: z.string().optional().default('default').describe('Memory namespace to search'),
+        includeRecommendations: z.boolean().optional().default(true).describe('Include actionable recommendations'),
+    }),
+    execute: async ({ query, limit, namespace, includeRecommendations }) => {
+        try {
+            // Step 1: Retrieve episodes from AgentDB
+            const agentDB = await AgentDBService.getInstance();
+            const episodes = await agentDB.recallEpisodes(query, limit);
+            if (episodes.length === 0) {
+                return JSON.stringify({
+                    success: true,
+                    data: {
+                        summary: 'No relevant memories found for the given query.',
+                        patterns: [],
+                        successRate: 0,
+                        averageReward: 0,
+                        recommendations: [],
+                        keyInsights: [],
+                        totalMemories: 0,
+                    },
+                    timestamp: new Date().toISOString(),
+                }, null, 2);
+            }
+            // Step 2: Synthesize using ContextSynthesizer
+            let synthesized;
+            try {
+                const { ContextSynthesizer } = await import(
+                /* webpackIgnore: true */ '../../../../packages/agentdb/dist/src/controllers/ContextSynthesizer.js');
+                synthesized = ContextSynthesizer.synthesize(episodes.map((ep) => ({
+                    task: ep.task,
+                    reward: ep.reward,
+                    success: ep.success,
+                    critique: ep.critique,
+                    input: ep.input,
+                    output: ep.output,
+                    similarity: ep.similarity,
+                })), { includeRecommendations, minPatternFrequency: 2 });
+            }
+            catch {
+                // Fallback: basic synthesis without ContextSynthesizer
+                const successCount = episodes.filter((ep) => ep.success).length;
+                const avgReward = episodes.reduce((sum, ep) => sum + (ep.reward || 0), 0) / episodes.length;
+                synthesized = {
+                    summary: `Found ${episodes.length} relevant memories with ${(successCount / episodes.length * 100).toFixed(0)}% success rate.`,
+                    patterns: [],
+                    successRate: successCount / episodes.length,
+                    averageReward: avgReward,
+                    recommendations: [],
+                    keyInsights: [`${episodes.length} episodes found`, `${successCount} successful`],
+                    totalMemories: episodes.length,
+                };
+            }
+            return JSON.stringify({
+                success: true,
+                data: synthesized,
+                timestamp: new Date().toISOString(),
+            }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: error.message,
+                timestamp: new Date().toISOString(),
+            }, null, 2);
+        }
+    }
+});
+// Tool 4: Swarm Init
+server.addTool({
+    name: 'swarm_init',
+    description: 'Initialize a multi-agent swarm with specified topology and strategy',
+    parameters: z.object({
+        topology: z.enum(['mesh', 'hierarchical', 'ring', 'star'])
+            .describe('Swarm topology: mesh (peer-to-peer), hierarchical (tree), ring (circular), star (centralized)'),
+        maxAgents: z.number().positive().optional().default(8).describe('Maximum number of agents in the swarm (1-100)')
+            .refine((val) => val >= 1 && val <= 100, { message: 'maxAgents must be between 1 and 100' }),
+        strategy: z.enum(['balanced', 'specialized', 'adaptive']).optional().default('balanced')
+            .describe('Agent distribution strategy: balanced (equal), specialized (role-based), adaptive (dynamic)')
+    }),
+    execute: async ({ topology, maxAgents, strategy }) => {
+        try {
+            const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            return JSON.stringify({
+                success: true,
+                topology,
+                maxAgents,
+                strategy,
+                message: 'Swarm initialized successfully',
+                details: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize swarm: ${error.message}`);
+        }
+    }
+});
+// Tool 5: Agent Spawn
+server.addTool({
+    name: 'agent_spawn',
+    description: 'Spawn a new agent in the swarm with specified type and capabilities',
+    parameters: z.object({
+        type: z.enum(['researcher', 'coder', 'analyst', 'optimizer', 'coordinator'])
+            .describe('Agent type: researcher (data gathering), coder (implementation), analyst (analysis), optimizer (performance), coordinator (orchestration)'),
+        capabilities: z.array(z.string()).optional()
+            .describe('Specific capabilities for the agent (e.g., ["python", "testing", "documentation"])'),
+        name: z.string().optional().describe('Custom agent name/identifier')
+    }),
+    execute: async ({ type, capabilities, name }) => {
+        try {
+            const capStr = capabilities ? ` --capabilities "${capabilities.join(',')}"` : '';
+            const nameStr = name ? ` --name "${name}"` : '';
+            const cmd = `npx claude-flow@alpha agent spawn --type ${type}${capStr}${nameStr}`;
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            return JSON.stringify({
+                success: true,
+                type,
+                capabilities: capabilities || [],
+                name: name || `${type}-${Date.now()}`,
+                message: 'Agent spawned successfully',
+                details: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to spawn agent: ${error.message}`);
+        }
+    }
+});
+// Tool 6: Task Orchestrate
+server.addTool({
+    name: 'task_orchestrate',
+    description: 'Orchestrate a complex task across the swarm with specified strategy and priority',
+    parameters: z.object({
+        task: z.string().min(1).describe('Task description or instructions for the swarm to execute'),
+        strategy: z.enum(['parallel', 'sequential', 'adaptive']).optional().default('adaptive')
+            .describe('Execution strategy: parallel (simultaneous), sequential (ordered), adaptive (dynamic based on task)'),
+        priority: z.enum(['low', 'medium', 'high', 'critical']).optional().default('medium')
+            .describe('Task priority level: low, medium, high, or critical'),
+        maxAgents: z.number().positive().optional().describe('Maximum number of agents to use for this task (1-10)')
+            .refine((val) => !val || (val >= 1 && val <= 10), { message: 'maxAgents must be between 1 and 10' })
+    }),
+    execute: async ({ task, strategy, priority, maxAgents }) => {
+        try {
+            const maxStr = maxAgents ? ` --max-agents ${maxAgents}` : '';
+            const cmd = `npx claude-flow@alpha task orchestrate "${task}" --strategy ${strategy} --priority ${priority}${maxStr}`;
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
+            return JSON.stringify({
+                success: true,
+                task,
+                strategy,
+                priority,
+                maxAgents: maxAgents || 'auto',
+                message: 'Task orchestrated successfully',
+                details: result.trim(),
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to orchestrate task: ${error.message}`);
+        }
+    }
+});
+// Tool 7: Agent Execute
+server.addTool({
+    name: 'agent_execute',
+    description: 'Execute a specific agent with a task (equivalent to --agent CLI command)',
+    parameters: z.object({
+        agent: z.string().describe('Agent name to execute'),
+        task: z.string().describe('Task description'),
+        stream: z.boolean().optional().default(false).describe('Enable streaming output')
+    }),
+    execute: async ({ agent, task, stream }) => {
+        try {
+            const streamFlag = stream ? '--stream' : '';
+            const cmd = `npx agentic-flow --agent "${agent}" --task "${task}" ${streamFlag}`.trim();
+            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
+            return JSON.stringify({
+                success: true,
+                agent,
+                task: task.substring(0, 100),
+                output: result,
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to execute agent: ${error.message}`);
+        }
+    }
+});
+// Tool 8: Agent Parallel
+server.addTool({
+    name: 'agent_parallel',
+    description: 'Run parallel mode with 3 agents (research, code review, data analysis)',
+    parameters: z.object({
+        topic: z.string().optional().describe('Research topic'),
+        diff: z.string().optional().describe('Code diff for review'),
+        dataset: z.string().optional().describe('Dataset hint'),
+        streaming: z.boolean().optional().default(false).describe('Enable streaming')
+    }),
+    execute: async ({ topic, diff, dataset, streaming }) => {
+        try {
+            const env = {
+                ...process.env,
+                ...(topic && { TOPIC: topic }),
+                ...(diff && { DIFF: diff }),
+                ...(dataset && { DATASET: dataset }),
+                ...(streaming && { ENABLE_STREAMING: 'true' })
+            };
+            const result = execSync('npx agentic-flow', { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000, env });
+            return JSON.stringify({
+                success: true,
+                mode: 'parallel',
+                agents: ['research', 'code_review', 'data'],
+                output: result,
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to run parallel mode: ${error.message}`);
+        }
+    }
+});
+// Tool 9: Agent List
+server.addTool({
+    name: 'agent_list',
+    description: 'List all available agents',
+    parameters: z.object({
+        format: z.enum(['summary', 'detailed', 'json']).optional().default('summary')
+    }),
+    execute: async ({ format }) => {
+        try {
+            const result = execSync('npx agentic-flow --list', { encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024, timeout: 30000 });
+            if (format === 'detailed') {
+                return result;
+            }
+            const agents = [];
+            const lines = result.split('\n');
+            let currentCategory = '';
+            for (const line of lines) {
+                if (line.includes(':') && line.trim().endsWith(':')) {
+                    currentCategory = line.replace(':', '').trim();
+                }
+                else if (line.trim().startsWith('•') || /^\s{2,}\w/.test(line)) {
+                    const match = line.match(/^\s*[•\s]*(\S+)\s+(.+)$/);
+                    if (match) {
+                        agents.push({ name: match[1], description: match[2].trim(), category: currentCategory });
+                    }
+                }
+            }
+            return JSON.stringify({
+                success: true,
+                count: agents.length,
+                agents,
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to list agents: ${error.message}`);
+        }
+    }
+});
+// Tool 10: Add Custom Agent
+server.addTool({
+    name: 'agent_add',
+    description: 'Add a new custom agent defined in markdown',
+    parameters: z.object({
+        name: z.string().describe('Agent name (kebab-case)'),
+        description: z.string().describe('Agent description'),
+        systemPrompt: z.string().describe('System prompt'),
+        category: z.string().optional().default('custom').describe('Category'),
+        capabilities: z.array(z.string()).optional().describe('Capabilities')
+    }),
+    execute: async ({ name, description, systemPrompt, category, capabilities }) => {
+        try {
+            const { writeFileSync, existsSync, mkdirSync } = await import('fs');
+            const { join } = await import('path');
+            const agentsDir = join(process.cwd(), '.claude', 'agents', category || 'custom');
+            if (!existsSync(agentsDir))
+                mkdirSync(agentsDir, { recursive: true });
+            const markdown = `# ${name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+## Description
+${description}
+
+## System Prompt
+${systemPrompt}
+
+${capabilities && capabilities.length > 0 ? `## Capabilities\n${capabilities.map(c => `- ${c}`).join('\n')}\n` : ''}
+
+## Usage
+\`\`\`bash
+npx agentic-flow --agent ${name} --task "Your task"
+\`\`\`
+
+---
+*Generated: ${new Date().toISOString()}*
+`;
+            const filePath = join(agentsDir, `${name}.md`);
+            if (existsSync(filePath))
+                throw new Error(`Agent '${name}' already exists`);
+            writeFileSync(filePath, markdown, 'utf8');
+            return JSON.stringify({
+                success: true,
+                agent: name,
+                category: category || 'custom',
+                filePath,
+                message: `Agent '${name}' created successfully`,
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to add agent: ${error.message}`);
+        }
+    }
+});
+// Tool 11: Add Custom Command
+server.addTool({
+    name: 'command_add',
+    description: 'Add a new custom command defined in markdown',
+    parameters: z.object({
+        name: z.string().describe('Command name (kebab-case)'),
+        description: z.string().describe('Command description'),
+        usage: z.string().describe('Usage example'),
+        parameters: z.array(z.object({
+            name: z.string(),
+            type: z.string(),
+            required: z.boolean(),
+            description: z.string()
+        })).optional().describe('Parameters'),
+        examples: z.array(z.string()).optional().describe('Examples')
+    }),
+    execute: async ({ name, description, usage, parameters, examples }) => {
+        try {
+            const { writeFileSync, existsSync, mkdirSync } = await import('fs');
+            const { join } = await import('path');
+            const commandsDir = join(process.cwd(), '.claude', 'commands');
+            if (!existsSync(commandsDir))
+                mkdirSync(commandsDir, { recursive: true });
+            const markdown = `# ${name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')} Command
+
+## Description
+${description}
+
+## Usage
+\`\`\`bash
+${usage}
+\`\`\`
+
+${parameters && parameters.length > 0 ? `## Parameters\n| Name | Type | Required | Description |\n|------|------|----------|-------------|\n${parameters.map(p => `| \`${p.name}\` | ${p.type} | ${p.required ? 'Yes' : 'No'} | ${p.description} |`).join('\n')}\n` : ''}
+
+${examples && examples.length > 0 ? `## Examples\n\n${examples.map((ex, i) => `### Example ${i + 1}\n\`\`\`bash\n${ex}\n\`\`\`\n`).join('\n')}` : ''}
+
+---
+*Generated: ${new Date().toISOString()}*
+`;
+            const filePath = join(commandsDir, `${name}.md`);
+            if (existsSync(filePath))
+                throw new Error(`Command '${name}' already exists`);
+            writeFileSync(filePath, markdown, 'utf8');
+            return JSON.stringify({
+                success: true,
+                command: name,
+                filePath,
+                message: `Command '${name}' created successfully`,
+                timestamp: new Date().toISOString()
+            }, null, 2);
+        }
+        catch (error) {
+            throw new Error(`Failed to add command: ${error.message}`);
+        }
+    }
+});
+// ---------------------------------------------------------------------------
+// AgentDB-powered tools (12 new tools using agentdb-service singleton)
+// ---------------------------------------------------------------------------
+// Tool 12: memory_episode_store
+server.addTool({
+    name: 'memory_episode_store',
+    description: 'Store an agent episode via ReflexionMemory for experience replay',
+    parameters: z.object({
+        sessionId: z.string().min(1).describe('Session identifier'),
+        task: z.string().min(1).describe('Task description'),
+        input: z.string().optional().describe('Input provided to the agent'),
+        output: z.string().optional().describe('Agent output/response'),
+        critique: z.string().optional().describe('Self-critique or reflection'),
+        reward: z.number().min(-1).max(1).describe('Reward signal (-1 to 1)'),
+        success: z.boolean().describe('Whether the episode was successful'),
+        tags: z.array(z.string()).optional().describe('Tags for categorization'),
+    }),
+    execute: async (params) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const id = await svc.storeEpisode(params);
+            return JSON.stringify({ success: true, data: { id }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 13: memory_episode_recall
+server.addTool({
+    name: 'memory_episode_recall',
+    description: 'Recall similar past episodes using semantic search',
+    parameters: z.object({
+        query: z.string().min(1).describe('Search query describing the task'),
+        limit: z.number().positive().optional().default(5).describe('Max results (1-50)'),
+    }),
+    execute: async ({ query, limit }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const episodes = await svc.recallEpisodes(query, limit);
+            return JSON.stringify({ success: true, data: { episodes, count: episodes.length }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 14: skill_publish
+server.addTool({
+    name: 'skill_publish',
+    description: 'Publish a reusable agent skill to the SkillLibrary',
+    parameters: z.object({
+        name: z.string().min(1).describe('Skill name'),
+        description: z.string().optional().describe('Skill description'),
+        code: z.string().optional().describe('Skill implementation code'),
+        successRate: z.number().min(0).max(1).describe('Success rate (0 to 1)'),
+        metadata: z.record(z.unknown()).optional().describe('Additional metadata'),
+    }),
+    execute: async (params) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const id = await svc.publishSkill(params);
+            return JSON.stringify({ success: true, data: { id, name: params.name }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 15: skill_find
+server.addTool({
+    name: 'skill_find',
+    description: 'Find applicable skills by description via semantic search',
+    parameters: z.object({
+        description: z.string().min(1).describe('Task description to match skills against'),
+        limit: z.number().positive().optional().default(5).describe('Max results'),
+    }),
+    execute: async ({ description, limit }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const skills = await svc.findSkills(description, limit);
+            return JSON.stringify({ success: true, data: { skills, count: skills.length }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 16: route_semantic
+server.addTool({
+    name: 'route_semantic',
+    description: 'Route a task to the optimal handler tier using semantic analysis (ADR-026)',
+    parameters: z.object({
+        taskDescription: z.string().min(1).describe('Task description to analyze for routing'),
+    }),
+    execute: async ({ taskDescription }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const route = await svc.routeSemantic(taskDescription);
+            return JSON.stringify({ success: true, data: route, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 17: route_causal
+server.addTool({
+    name: 'route_causal',
+    description: 'Causal routing via CausalMemoryGraph to find optimal agent path',
+    parameters: z.object({
+        taskType: z.string().min(1).describe('Type of task to route'),
+        agentTypes: z.array(z.string()).min(1).describe('Candidate agent types to consider'),
+    }),
+    execute: async ({ taskType, agentTypes }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const patterns = await svc.searchPatterns(taskType, 10);
+            const ranked = agentTypes.map((agent) => {
+                const matching = patterns.filter((p) => p.approach.toLowerCase().includes(agent.toLowerCase()));
+                const avgSuccess = matching.length > 0
+                    ? matching.reduce((sum, p) => sum + p.successRate, 0) / matching.length
+                    : 0.5;
+                return { agent, score: avgSuccess, matchCount: matching.length };
+            }).sort((a, b) => b.score - a.score);
+            return JSON.stringify({ success: true, data: { taskType, ranked }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 18: attention_coordinate
+server.addTool({
+    name: 'attention_coordinate',
+    description: 'Coordinate agents using attention-weighted task assignment',
+    parameters: z.object({
+        agents: z.array(z.string()).min(1).describe('Agent names to coordinate'),
+        task: z.string().min(1).describe('Task to assign'),
+        mechanism: z.enum(['softmax', 'uniform', 'priority']).optional().default('softmax')
+            .describe('Attention mechanism: softmax, uniform, or priority'),
+    }),
+    execute: async ({ agents, task, mechanism }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const skills = await svc.findSkills(task, agents.length);
+            const weights = agents.map((agent, i) => {
+                const skill = skills[i];
+                if (mechanism === 'uniform')
+                    return 1 / agents.length;
+                if (mechanism === 'priority')
+                    return 1 / (i + 1);
+                return skill ? skill.successRate : 1 / agents.length;
+            });
+            const sum = weights.reduce((a, b) => a + b, 0) || 1;
+            const assignments = agents.map((agent, i) => ({
+                agent, weight: weights[i] / sum, task,
+            }));
+            return JSON.stringify({ success: true, data: { mechanism, assignments }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 19: graph_query
+server.addTool({
+    name: 'graph_query',
+    description: 'Query the agent knowledge graph',
+    parameters: z.object({
+        query: z.string().min(1).describe('Graph query string (natural language or keyword)'),
+        limit: z.number().positive().optional().default(10).describe('Max results'),
+    }),
+    execute: async ({ query, limit }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const results = await svc.queryGraph(query);
+            return JSON.stringify({ success: true, data: { results: results.slice(0, limit), count: results.length }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 20: graph_store
+server.addTool({
+    name: 'graph_store',
+    description: 'Store nodes and edges in the agent knowledge graph',
+    parameters: z.object({
+        nodes: z.array(z.object({
+            id: z.string(), type: z.string(), label: z.string().optional(),
+        })).describe('Graph nodes'),
+        edges: z.array(z.object({
+            from: z.string(), to: z.string(),
+            fromType: z.string().optional(), toType: z.string().optional(),
+            similarity: z.number().optional(), confidence: z.number().optional(),
+        })).describe('Graph edges'),
+    }),
+    execute: async ({ nodes, edges }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            await svc.storeGraphState(nodes, edges);
+            return JSON.stringify({ success: true, data: { nodesStored: nodes.length, edgesStored: edges.length }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 21: learning_trajectory
+server.addTool({
+    name: 'learning_trajectory',
+    description: 'Record a learning trajectory (state-action-reward sequence)',
+    parameters: z.object({
+        steps: z.array(z.object({
+            state: z.string(), action: z.string(), reward: z.number(),
+            nextState: z.string().optional(),
+        })).min(1).describe('Trajectory steps'),
+        reward: z.number().describe('Total trajectory reward'),
+    }),
+    execute: async ({ steps, reward }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            await svc.recordTrajectory(steps, reward);
+            return JSON.stringify({ success: true, data: { stepsRecorded: steps.length, totalReward: reward }, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 22: learning_predict
+server.addTool({
+    name: 'learning_predict',
+    description: 'Predict the optimal action for a given state using learned policy',
+    parameters: z.object({
+        state: z.string().min(1).describe('Current state description'),
+    }),
+    execute: async ({ state }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const prediction = await svc.predictAction(state);
+            return JSON.stringify({ success: true, data: prediction, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Tool 23: explain_decision
+server.addTool({
+    name: 'explain_decision',
+    description: 'Get an explainable Merkle proof for a recall decision',
+    parameters: z.object({
+        decisionId: z.string().min(1).describe('Decision/query ID to explain'),
+    }),
+    execute: async ({ decisionId }) => {
+        try {
+            const svc = await AgentDBService.getInstance();
+            const explanation = await svc.explainDecision(decisionId);
+            return JSON.stringify({ success: true, data: explanation, timestamp: new Date().toISOString() }, null, 2);
+        }
+        catch (error) {
+            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
+        }
+    }
+});
+// Register modular tool sets (120+ additional tools)
+// Note: Infrastructure and Workflow tools will use DirectCallBridge when available
+registerSessionTools(server); // 8 tools
+registerGitHubTools(server); // 8 tools
+registerNeuralTools(server); // 6 tools
+registerRuVectorTools(server); // 6 tools
+registerSonaRvfTools(server); // 11 tools
+registerInfrastructureTools(server, () => directBridge); // 13 tools (DirectCallBridge-enabled)
+registerAutopilotTools(server); // 10 tools
+registerPerformanceTools(server); // 15 tools
+registerWorkflowTools(server, () => directBridge); // 11 tools (DirectCallBridge-enabled)
+registerDAATools(server); // 10 tools
+registerAttentionTools(server); // 3 tools
+registerHiddenControllerTools(server); // 17 tools (8 controllers)
+registerQUICTools(server); // 7 tools (QUIC protocol: sync, latency, health, pool, 0rtt, multiplex)
+registerRVFTools(server); // 5 tools (RVF optimizer - ADR-063)
+registerCostOptimizerTools(server); // 4 tools (Cost optimizer - ADR-064)
+registerStreamingTools(server); // 10 tools (Streaming architecture - ADR-065 P1-3)
+registerSonaTools(server); // 8 tools (SONA RL Loop - ADR-065 P1-2)
+registerMemoryTools(server); // 6 tools (Hierarchical Memory - ADR-066 P2-3)
+registerQuantizationTools(server); // 8 tools (Model Quantization - ADR-066 P2-2)
+registerExplainabilityTools(server); // 10 tools (Explainability Dashboard - ADR-066 P2-4)
+console.error('Registered 208+ tools successfully');
+console.error('Starting stdio transport...');
+// Start with stdio transport
+server.start({ transportType: 'stdio' }).then(() => {
+    console.error('FastMCP Full Server running on stdio');
+}).catch((error) => {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=stdio-full.js.map