agentic-flow 3.0.0-alpha.2 → 3.0.0

package/dist/mcp/fastmcp/servers/stdio-full.js

@@ -1,66 +1,21 @@
 #!/usr/bin/env node
-// Full FastMCP server with stdio transport - All 86 claude-flow-sdk tools
+/* eslint-disable @typescript-eslint/no-explicit-any -- pre-existing catch(error: any) handlers; outside scope of CWE-78 fix */
+// Full FastMCP server with stdio transport - All 11 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)');
+import { execFileSync } from 'child_process';
+import { assertSlug, resolveAgentDir, resolveWithin } from '../../../utils/path-safety.js';
+// Security: All shell-outs use execFileSync with argv arrays (shell: false) to
+// prevent OS command injection via tool parameters (CWE-78). Do NOT reintroduce
+// execSync with template-string interpolation here.
+const NPX_EXEC_OPTS = { shell: false };
+console.error('🚀 Starting FastMCP Full Server (stdio transport)...');
+console.error('📦 Loading 11 tools: memory (3), swarm (3), agent (5)');
 // 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(agentDB, hooks);
-        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',
@@ -73,14 +28,10 @@ server.addTool({
     }),
     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 });
+            const args = ['claude-flow@alpha', 'memory', 'store', key, value, '--namespace', namespace];
+            if (ttl)
+                args.push('--ttl', String(ttl));
+            execFileSync('npx', args, { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
             return JSON.stringify({
                 success: true,
                 key,
@@ -106,8 +57,7 @@ server.addTool({
     }),
     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 });
+            const result = execFileSync('npx', ['claude-flow@alpha', 'memory', 'retrieve', key, '--namespace', namespace], { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
             return JSON.stringify({
                 success: true,
                 key,
@@ -133,13 +83,11 @@ server.addTool({
     }),
     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 });
+            const args = ['claude-flow@alpha', 'memory', 'search', pattern];
+            if (namespace)
+                args.push('--namespace', namespace);
+            args.push('--limit', String(limit));
+            const result = execFileSync('npx', args, { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
             return JSON.stringify({
                 success: true,
                 pattern,
@@ -154,80 +102,6 @@ server.addTool({
         }
     }
 });
-// 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/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',
@@ -242,8 +116,7 @@ server.addTool({
     }),
     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 });
+            const result = execFileSync('npx', ['claude-flow@alpha', 'swarm', 'init', '--topology', topology, '--max-agents', String(maxAgents), '--strategy', strategy], { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
             return JSON.stringify({
                 success: true,
                 topology,
@@ -272,10 +145,12 @@ server.addTool({
     }),
     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 });
+            const args = ['claude-flow@alpha', 'agent', 'spawn', '--type', type];
+            if (capabilities && capabilities.length > 0)
+                args.push('--capabilities', capabilities.join(','));
+            if (name)
+                args.push('--name', name);
+            const result = execFileSync('npx', args, { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
             return JSON.stringify({
                 success: true,
                 type,
@@ -306,9 +181,10 @@ server.addTool({
     }),
     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 });
+            const args = ['claude-flow@alpha', 'task', 'orchestrate', task, '--strategy', strategy, '--priority', priority];
+            if (maxAgents)
+                args.push('--max-agents', String(maxAgents));
+            const result = execFileSync('npx', args, { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
             return JSON.stringify({
                 success: true,
                 task,
@@ -336,9 +212,10 @@ server.addTool({
     }),
     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 });
+            const args = ['agentic-flow', '--agent', agent, '--task', task];
+            if (stream)
+                args.push('--stream');
+            const result = execFileSync('npx', args, { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
             return JSON.stringify({
                 success: true,
                 agent,
@@ -371,7 +248,7 @@ server.addTool({
                 ...(dataset && { DATASET: dataset }),
                 ...(streaming && { ENABLE_STREAMING: 'true' })
             };
-            const result = execSync('npx agentic-flow', { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000, env });
+            const result = execFileSync('npx', ['agentic-flow'], { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000, env });
             return JSON.stringify({
                 success: true,
                 mode: 'parallel',
@@ -394,7 +271,7 @@ server.addTool({
     }),
     execute: async ({ format }) => {
         try {
-            const result = execSync('npx agentic-flow --list', { encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024, timeout: 30000 });
+            const result = execFileSync('npx', ['agentic-flow', '--list'], { ...NPX_EXEC_OPTS, encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024, timeout: 30000 });
             if (format === 'detailed') {
                 return result;
             }
@@ -439,7 +316,9 @@ server.addTool({
         try {
             const { writeFileSync, existsSync, mkdirSync } = await import('fs');
             const { join } = await import('path');
-            const agentsDir = join(process.cwd(), '.claude', 'agents', category || 'custom');
+            // name and category become path segments: slugs only, kept under .claude/agents
+            assertSlug(name, 'agent name');
+            const agentsDir = resolveAgentDir(category || 'custom');
             if (!existsSync(agentsDir))
                 mkdirSync(agentsDir, { recursive: true });
             const markdown = `# ${name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
@@ -460,7 +339,7 @@ npx agentic-flow --agent ${name} --task "Your task"
 ---
 *Generated: ${new Date().toISOString()}*
 `;
-            const filePath = join(agentsDir, `${name}.md`);
+            const filePath = resolveWithin(agentsDir, `${name}.md`);
             if (existsSync(filePath))
                 throw new Error(`Agent '${name}' already exists`);
             writeFileSync(filePath, markdown, 'utf8');
@@ -498,6 +377,7 @@ server.addTool({
         try {
             const { writeFileSync, existsSync, mkdirSync } = await import('fs');
             const { join } = await import('path');
+            assertSlug(name, 'command name');
             const commandsDir = join(process.cwd(), '.claude', 'commands');
             if (!existsSync(commandsDir))
                 mkdirSync(commandsDir, { recursive: true });
@@ -518,7 +398,7 @@ ${examples && examples.length > 0 ? `## Examples\n\n${examples.map((ex, i) => `#
 ---
 *Generated: ${new Date().toISOString()}*
 `;
-            const filePath = join(commandsDir, `${name}.md`);
+            const filePath = resolveWithin(commandsDir, `${name}.md`);
             if (existsSync(filePath))
                 throw new Error(`Command '${name}' already exists`);
             writeFileSync(filePath, markdown, 'utf8');
@@ -535,302 +415,13 @@ ${examples && examples.length > 0 ? `## Examples\n\n${examples.map((ex, i) => `#
         }
     }
 });
-// ---------------------------------------------------------------------------
-// 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...');
+console.error('✅ Registered 11 tools successfully');
+console.error('🔌 Starting stdio transport...');
 // Start with stdio transport
 server.start({ transportType: 'stdio' }).then(() => {
-    console.error('FastMCP Full Server running on stdio');
+    console.error('✅ FastMCP Full Server running on stdio');
 }).catch((error) => {
-    console.error('Failed to start server:', error);
+    console.error('❌ Failed to start server:', error);
     process.exit(1);
 });
 //# sourceMappingURL=stdio-full.js.map