sdlc-agent-4-enterprise-server 1.0.0

package/src/modules/memory/models.ts

@@ -0,0 +1,106 @@
+/**
+ * Data models for the memory engine.
+ */
+
+/** KB Scope — determines visibility isolation level. */
+export type KBScope = 'USER' | 'PROJECT' | 'SHARED';
+
+/** Context passed to every tool call for scope enforcement. */
+export interface ScopeContext {
+  userId: string;
+  projectId?: string;
+}
+
+export interface KnowledgeEntry {
+  id: number;
+  content: string;
+  summary: string;
+  type: string;
+  tier: string;
+  scope: KBScope;
+  user_id: string | null;
+  source: string | null;
+  source_ref: string | null;
+  tags: string;
+  confidence: number;
+  access_count: number;
+  created_at: string;
+  updated_at: string;
+  last_accessed_at: string | null;
+  expires_at: string | null;
+  pinned: number;
+  pin_order: number;
+  structured_map: string;
+  quality_score: number | null;
+  archived: number;
+  agent_name: string | null;
+  owner: string | null;
+}
+
+export interface SearchResult {
+  entry: KnowledgeEntry;
+  score: number;
+  matchType: string;
+}
+
+export interface GraphEdge {
+  id: number;
+  source_id: number;
+  target_id: number;
+  relation: string;
+  weight: number;
+  metadata: string | null;
+  created_at: string;
+}
+
+export interface MemorySession {
+  id: number;
+  session_id: string;
+  agent_name: string | null;
+  started_at: string;
+  ended_at: string | null;
+  observation_count: number;
+  status: string;
+}
+
+export interface AuditEntry {
+  id: number;
+  operation: string;
+  entry_id: number | null;
+  session_id: string | null;
+  agent_name: string | null;
+  details: string | null;
+  created_at: string;
+}
+
+export interface TierStats {
+  tier: string;
+  entryCount: number;
+  avgConfidence: number;
+  avgAccessCount: number;
+}
+
+export interface ConsolidationResult {
+  promoted: number;
+  demoted: number;
+  expired: number;
+}
+
+export interface ConversationTurn {
+  id: number;
+  session_id: string;
+  turn_number: number;
+  role: string;
+  content: string;
+  tool_calls: string | null;
+  metadata: string | null;
+  summarized: number;
+  created_at: string;
+}
+
+export interface ConversationSession {
+  session_id: string;
+  turn_count: number;
+  roles: string[];
+  last_turn_at: string;
+}

package/src/modules/memory/schema.ts

@@ -0,0 +1,269 @@
+/**
+ * Memory Schema DDL — Full KB system (FTS5 + vector-ready + graph).
+ * Ported from mcp-code-intelligence-nodejs extension.
+ */
+
+export const MEMORY_SCHEMA = `
+CREATE TABLE IF NOT EXISTS knowledge_entries (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  content TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  type TEXT NOT NULL,
+  tier TEXT NOT NULL DEFAULT 'WORKING',
+  scope TEXT NOT NULL DEFAULT 'USER',
+  user_id TEXT DEFAULT NULL,
+  source TEXT,
+  source_ref TEXT,
+  tags TEXT NOT NULL DEFAULT '',
+  confidence REAL NOT NULL DEFAULT 1.0,
+  access_count INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  last_accessed_at TEXT,
+  expires_at TEXT,
+  pinned INTEGER NOT NULL DEFAULT 0,
+  pin_order INTEGER NOT NULL DEFAULT 0,
+  structured_map TEXT NOT NULL DEFAULT '{}',
+  quality_score INTEGER DEFAULT NULL,
+  archived INTEGER NOT NULL DEFAULT 0,
+  agent_name TEXT DEFAULT NULL,
+  owner TEXT DEFAULT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_fts USING fts5(
+  summary, content, tags, type,
+  content=knowledge_entries, content_rowid=id,
+  tokenize='porter unicode61'
+);
+
+CREATE TRIGGER IF NOT EXISTS knowledge_fts_ai AFTER INSERT ON knowledge_entries BEGIN
+  INSERT INTO knowledge_fts(rowid, summary, content, tags, type)
+  VALUES (new.id, new.summary, new.content, new.tags, new.type);
+END;
+CREATE TRIGGER IF NOT EXISTS knowledge_fts_ad AFTER DELETE ON knowledge_entries BEGIN
+  INSERT INTO knowledge_fts(knowledge_fts, rowid, summary, content, tags, type)
+  VALUES ('delete', old.id, old.summary, old.content, old.tags, old.type);
+END;
+CREATE TRIGGER IF NOT EXISTS knowledge_fts_au AFTER UPDATE ON knowledge_entries BEGIN
+  INSERT INTO knowledge_fts(knowledge_fts, rowid, summary, content, tags, type)
+  VALUES ('delete', old.id, old.summary, old.content, old.tags, old.type);
+  INSERT INTO knowledge_fts(rowid, summary, content, tags, type)
+  VALUES (new.id, new.summary, new.content, new.tags, new.type);
+END;
+
+CREATE TABLE IF NOT EXISTS knowledge_vectors (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entry_id INTEGER NOT NULL UNIQUE,
+  vector BLOB NOT NULL,
+  model TEXT NOT NULL DEFAULT 'paraphrase-multilingual-MiniLM-L12-v2',
+  dimensions INTEGER NOT NULL DEFAULT 384,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS knowledge_graph_edges (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source_id INTEGER NOT NULL,
+  target_id INTEGER NOT NULL,
+  relation TEXT NOT NULL,
+  weight REAL NOT NULL DEFAULT 1.0,
+  metadata TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (source_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE,
+  FOREIGN KEY (target_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS consolidation_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entry_id INTEGER NOT NULL,
+  from_tier TEXT NOT NULL,
+  to_tier TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  consolidated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS memory_sessions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL UNIQUE,
+  agent_name TEXT,
+  started_at TEXT NOT NULL DEFAULT (datetime('now')),
+  ended_at TEXT,
+  observation_count INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'active'
+);
+
+CREATE TABLE IF NOT EXISTS memory_audit (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  operation TEXT NOT NULL,
+  entry_id INTEGER,
+  session_id TEXT,
+  agent_name TEXT,
+  details TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS conversation_turns (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  turn_number INTEGER NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT NOT NULL,
+  tool_calls TEXT,
+  metadata TEXT,
+  summarized INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS entity_index (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entry_id INTEGER NOT NULL,
+  entity_name TEXT NOT NULL,
+  entity_type TEXT NOT NULL,
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS agent_scope_config (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_role TEXT NOT NULL UNIQUE,
+  tag_set TEXT NOT NULL DEFAULT '[]',
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS quality_scores (
+  entry_id INTEGER PRIMARY KEY,
+  total_score INTEGER NOT NULL DEFAULT 0,
+  dimensions TEXT NOT NULL DEFAULT '{}',
+  scored_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  category TEXT DEFAULT NULL,
+  parent_tag TEXT DEFAULT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS entry_tags (
+  entry_id INTEGER NOT NULL,
+  tag_id INTEGER NOT NULL,
+  PRIMARY KEY (entry_id, tag_id),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE,
+  FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS citations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entry_id INTEGER NOT NULL,
+  cited_by TEXT NOT NULL,
+  context TEXT DEFAULT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE,
+  UNIQUE(entry_id, cited_by, context)
+);
+
+CREATE TABLE IF NOT EXISTS attachments (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entry_id INTEGER NOT NULL,
+  file_path TEXT NOT NULL,
+  file_name TEXT NOT NULL,
+  mime_type TEXT NOT NULL DEFAULT 'application/octet-stream',
+  description TEXT DEFAULT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS templates (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  type TEXT NOT NULL,
+  required_sections TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS feedback (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entry_id INTEGER NOT NULL,
+  rating INTEGER NOT NULL,
+  comment TEXT DEFAULT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS reminders (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entry_id INTEGER NOT NULL,
+  assignee TEXT DEFAULT NULL,
+  interval_days INTEGER NOT NULL DEFAULT 90,
+  next_due TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  snoozed_until TEXT DEFAULT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (entry_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS search_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  query TEXT NOT NULL,
+  result_count INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS popular_queries (
+  query TEXT PRIMARY KEY,
+  hit_count INTEGER NOT NULL DEFAULT 1,
+  avg_results REAL NOT NULL DEFAULT 0,
+  last_searched TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_ke_tier ON knowledge_entries(tier);
+CREATE INDEX IF NOT EXISTS idx_ke_scope ON knowledge_entries(scope);
+CREATE INDEX IF NOT EXISTS idx_ke_user_id ON knowledge_entries(user_id);
+CREATE INDEX IF NOT EXISTS idx_ke_scope_user ON knowledge_entries(scope, user_id);
+CREATE INDEX IF NOT EXISTS idx_ke_type ON knowledge_entries(type);
+CREATE INDEX IF NOT EXISTS idx_ke_source ON knowledge_entries(source);
+CREATE INDEX IF NOT EXISTS idx_ke_confidence ON knowledge_entries(confidence);
+CREATE INDEX IF NOT EXISTS idx_ke_access ON knowledge_entries(access_count);
+CREATE INDEX IF NOT EXISTS idx_ke_created ON knowledge_entries(created_at);
+CREATE INDEX IF NOT EXISTS idx_ke_expires ON knowledge_entries(expires_at);
+CREATE INDEX IF NOT EXISTS idx_ke_pinned ON knowledge_entries(pinned, pin_order);
+CREATE INDEX IF NOT EXISTS idx_ke_archived ON knowledge_entries(archived);
+CREATE INDEX IF NOT EXISTS idx_ke_quality ON knowledge_entries(quality_score);
+CREATE INDEX IF NOT EXISTS idx_ke_agent_name ON knowledge_entries(agent_name);
+CREATE INDEX IF NOT EXISTS idx_ke_tier_archived ON knowledge_entries(tier, archived, created_at);
+CREATE INDEX IF NOT EXISTS idx_kv_entry ON knowledge_vectors(entry_id);
+CREATE INDEX IF NOT EXISTS idx_kge_source ON knowledge_graph_edges(source_id);
+CREATE INDEX IF NOT EXISTS idx_kge_target ON knowledge_graph_edges(target_id);
+CREATE INDEX IF NOT EXISTS idx_kge_relation ON knowledge_graph_edges(relation);
+CREATE INDEX IF NOT EXISTS idx_cl_entry ON consolidation_log(entry_id);
+CREATE INDEX IF NOT EXISTS idx_ms_session ON memory_sessions(session_id);
+CREATE INDEX IF NOT EXISTS idx_ms_status ON memory_sessions(status);
+CREATE INDEX IF NOT EXISTS idx_ma_operation ON memory_audit(operation);
+CREATE INDEX IF NOT EXISTS idx_ma_entry ON memory_audit(entry_id);
+CREATE INDEX IF NOT EXISTS idx_ma_session ON memory_audit(session_id);
+CREATE INDEX IF NOT EXISTS idx_ma_created ON memory_audit(created_at);
+CREATE INDEX IF NOT EXISTS idx_ct_session ON conversation_turns(session_id, turn_number);
+CREATE INDEX IF NOT EXISTS idx_ct_role ON conversation_turns(role);
+CREATE INDEX IF NOT EXISTS idx_ct_created ON conversation_turns(created_at);
+CREATE INDEX IF NOT EXISTS idx_ct_summarized ON conversation_turns(summarized);
+CREATE INDEX IF NOT EXISTS idx_ei_name ON entity_index(entity_name);
+CREATE INDEX IF NOT EXISTS idx_ei_type ON entity_index(entity_type);
+CREATE INDEX IF NOT EXISTS idx_ei_entry ON entity_index(entry_id);
+CREATE INDEX IF NOT EXISTS idx_citations_entry ON citations(entry_id);
+CREATE INDEX IF NOT EXISTS idx_attachments_entry ON attachments(entry_id);
+CREATE INDEX IF NOT EXISTS idx_feedback_entry ON feedback(entry_id);
+CREATE INDEX IF NOT EXISTS idx_reminders_entry ON reminders(entry_id);
+CREATE INDEX IF NOT EXISTS idx_reminders_status ON reminders(status);
+CREATE INDEX IF NOT EXISTS idx_search_log_created ON search_log(created_at);
+
+-- Default agent scope config
+INSERT OR IGNORE INTO agent_scope_config (agent_role, tag_set) VALUES
+  ('QA', '["testing","qa","test-plan","test-case","bug"]'),
+  ('DEV', '["code","api","architecture","implementation","design"]'),
+  ('BA', '["requirement","business","stakeholder","process"]'),
+  ('SA', '["architecture","design","infrastructure","security"]'),
+  ('DEVOPS', '["deployment","infrastructure","ci-cd","monitoring"]');
+`;

package/src/modules/memory/tool-definitions.ts

@@ -0,0 +1,31 @@
+/**
+ * Tool definitions for Memory module — 14 consolidated tools.
+ */
+import type { ToolDefinition } from '../../types/tool.js';
+
+export const TOOL_DEFINITIONS: ToolDefinition[] = [
+  { name: 'mem_search', description: 'Hybrid search across KB (BM25 + graph).', inputSchema: { type: 'object', properties: { query: { type: 'string' }, limit: { type: 'number' }, tier: { type: 'string' }, type: { type: 'string' }, detail: { type: 'boolean' } }, required: ['query'] }, category: 'memory' },
+  { name: 'mem_ingest', description: 'Store a knowledge entry.', inputSchema: { type: 'object', properties: { content: { type: 'string' }, summary: { type: 'string' }, type: { type: 'string' }, source: { type: 'string' }, tags: { type: 'string' }, agent_name: { type: 'string' } }, required: ['content'] }, category: 'memory' },
+  { name: 'mem_ingest_file', description: 'Ingest document from disk by path.', inputSchema: { type: 'object', properties: { file_path: { type: 'string' }, type: { type: 'string' } }, required: ['file_path'] }, category: 'memory' },
+  { name: 'mem_pin', description: 'Core Memory: pin/unpin entries for auto-recall.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, entry_id: { type: 'number' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_map', description: 'Structured Map: view/update entry metadata.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, entry_id: { type: 'number' }, map: { type: 'object' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_crud', description: 'CRUD operations: get, delete, list.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, id: { type: 'number' }, tier: { type: 'string' }, type: { type: 'string' }, limit: { type: 'number' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_graph', description: 'Knowledge graph: neighbors, add_edge, path.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, node_id: { type: 'number' }, source_id: { type: 'number' }, target_id: { type: 'number' }, relation: { type: 'string' } } }, category: 'memory' },
+  { name: 'mem_consolidate', description: 'Tier consolidation: promote/demote entries.', inputSchema: { type: 'object', properties: { dry_run: { type: 'boolean' } } }, category: 'memory' },
+  { name: 'mem_lifecycle', description: 'Entry lifecycle: staleness, archive, reminders.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, entry_id: { type: 'number' }, interval_days: { type: 'number' }, assignee: { type: 'string' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_templates', description: 'Manage content templates.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, name: { type: 'string' }, type: { type: 'string' }, required_sections: { type: 'string' }, entry_id: { type: 'number' } } }, category: 'memory' },
+  { name: 'mem_attachments', description: 'File attachments for entries.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, entry_id: { type: 'number' }, file_path: { type: 'string' }, attachment_id: { type: 'number' } } }, category: 'memory' },
+  { name: 'mem_discover', description: 'Find relevant entries: suggest or related.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, query: { type: 'string' }, entry_id: { type: 'number' }, limit: { type: 'number' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_tags', description: 'Tag taxonomy: create, tag, untag, search.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, tag: { type: 'string' }, tags: { type: 'string' }, entry_id: { type: 'number' }, category: { type: 'string' }, operator: { type: 'string' } } }, category: 'memory' },
+  { name: 'mem_citations', description: 'Citation tracking: record, most_cited, uncited.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, entry_id: { type: 'number' }, cited_by: { type: 'string' }, context: { type: 'string' }, limit: { type: 'number' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_conversation', description: 'Conversation history: save turns, query.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, session_id: { type: 'string' }, role: { type: 'string' }, content: { type: 'string' }, query: { type: 'string' }, limit: { type: 'number' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_scoring', description: 'Quality scoring + feedback.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, entry_id: { type: 'number' }, rating: { type: 'number' }, comment: { type: 'string' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_admin', description: 'System admin: status, audit, sessions, analytics.', inputSchema: { type: 'object', properties: { action: { type: 'string' }, limit: { type: 'number' }, operation: { type: 'string' } }, required: ['action'] }, category: 'memory' },
+  { name: 'mem_get', description: 'Get a knowledge entry by ID (alias for mem_crud get).', inputSchema: { type: 'object', properties: { id: { type: 'number' } }, required: ['id'] }, category: 'memory' },
+  { name: 'mem_delete', description: 'Delete a knowledge entry by ID (alias for mem_crud delete).', inputSchema: { type: 'object', properties: { id: { type: 'number' } }, required: ['id'] }, category: 'memory' },
+  { name: 'mem_list', description: 'List knowledge entries (alias for mem_crud list).', inputSchema: { type: 'object', properties: { limit: { type: 'number' }, tier: { type: 'string' }, type: { type: 'string' } } }, category: 'memory' },
+  { name: 'mem_status', description: 'Get memory status (alias for mem_admin status).', inputSchema: { type: 'object', properties: {} }, category: 'memory' },
+  { name: 'mem_audit', description: 'Get memory audit log (alias for mem_admin audit).', inputSchema: { type: 'object', properties: { limit: { type: 'number' }, operation: { type: 'string' } } }, category: 'memory' },
+  { name: 'mem_sessions', description: 'List memory sessions (alias for mem_admin sessions).', inputSchema: { type: 'object', properties: {} }, category: 'memory' },
+];
+

package/src/modules/orchestration/McpClientManager.ts

@@ -0,0 +1,209 @@
+import fs from 'fs';
+import path from 'path';
+import type { Logger } from 'pino';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { loadConfig, getWorkspacePath } from '../../config/BackendConfig.js';
+import type { ToolDefinition } from '../../types/tool.js';
+
+export class McpClientManager {
+  private clients: Map<string, Client> = new Map();
+  private toolsToServer: Map<string, string> = new Map();
+  private proxiedTools: ToolDefinition[] = [];
+  private logger: Logger;
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'McpClientManager' });
+  }
+
+  async initializeAll(): Promise<void> {
+    const cfg = loadConfig();
+    const configPath = path.resolve(getWorkspacePath(), cfg.dataDir, cfg.orchestrationConfigPath);
+    if (!fs.existsSync(configPath)) {
+      this.logger.warn({ configPath }, 'orchestration.json not found, skipping child servers');
+      return;
+    }
+
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      const servers = config.mcpServers || {};
+
+      const connectPromises = Object.entries(servers).map(async ([serverName, serverConfig]: [string, any]) => {
+        if (serverConfig.disabled) {
+          this.logger.info({ serverName }, 'Skipping disabled server');
+          return;
+        }
+        // Skip code-intelligence since it's us
+        if (serverName === 'code-intelligence') {
+          return;
+        }
+
+        try {
+          this.logger.info({ serverName }, 'Connecting to child MCP server');
+          const client = new Client({ name: 'code-intel-orchestrator', version: '1.0.0' }, { capabilities: {} });
+          
+          let transport: any;
+          if (serverConfig.type === 'sse' || serverConfig.transportType === 'sse') {
+            transport = new SSEClientTransport(new URL(serverConfig.url));
+          } else if (serverConfig.type === 'httpStream' || serverConfig.transportType === 'httpStream') {
+            transport = new StreamableHTTPClientTransport(new URL(serverConfig.url));
+          } else if (serverConfig.command) {
+            transport = new StdioClientTransport({
+              command: serverConfig.command,
+              args: serverConfig.args || [],
+              env: { ...process.env, ...(serverConfig.env || {}) }
+            });
+          } else {
+            this.logger.warn({ serverName }, 'Unknown transport type configuration');
+            return;
+          }
+
+          // Don't wait forever, add a timeout for connecting
+          const connectPromise = client.connect(transport);
+          await Promise.race([
+            connectPromise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), 10000))
+          ]);
+
+          this.clients.set(serverName, client);
+          this.logger.info({ serverName }, 'Connected to child server. Fetching tools...');
+
+          // Fetch tools
+          const toolsResult = await client.listTools();
+          const tools = toolsResult.tools || [];
+          
+          for (const tool of tools) {
+            this.toolsToServer.set(tool.name, serverName);
+            this.proxiedTools.push({
+              name: tool.name,
+              description: tool.description || '',
+              category: serverName as any,
+              inputSchema: tool.inputSchema as any
+            });
+          }
+          this.logger.info({ serverName, toolCount: tools.length }, 'Imported tools from child server');
+        } catch (err: any) {
+          this.logger.error({ err: err.message, serverName }, 'Failed to connect to child server');
+        }
+      });
+
+      // Wait for all connections to settle
+      await Promise.allSettled(connectPromises);
+
+    } catch (err) {
+      this.logger.error({ err }, 'Failed to parse orchestration.json');
+    }
+  }
+
+  getProxiedTools(): ToolDefinition[] {
+    return this.proxiedTools;
+  }
+
+  ownsTool(toolName: string): boolean {
+    return this.toolsToServer.has(toolName);
+  }
+
+  async executeTool(toolName: string, args: any): Promise<any> {
+    const serverName = this.toolsToServer.get(toolName);
+    if (!serverName) {
+      throw new Error(`Tool ${toolName} is not managed by any child server`);
+    }
+
+    const client = this.clients.get(serverName);
+    if (!client) {
+      throw new Error(`Client for server ${serverName} is disconnected`);
+    }
+
+    this.logger.info({ toolName, serverName }, 'Proxying tool execution to child server');
+    
+    try {
+      const result = await client.callTool({
+        name: toolName,
+        arguments: args
+      });
+      return {
+        content: result.content,
+        isError: result.isError
+      };
+    } catch (err: any) {
+      this.logger.error({ err, toolName, serverName }, 'Tool execution failed on child server');
+      throw err;
+    }
+  }
+
+  async shutdownAll(): Promise<void> {
+    for (const [name, client] of this.clients.entries()) {
+      try {
+        await client.close();
+      } catch (e) {
+        this.logger.error({ err: e, serverName: name }, 'Error closing client');
+      }
+    }
+  }
+
+  // --- Config Persistence API support ---
+
+  isServerConnected(name: string): boolean {
+    return this.clients.has(name);
+  }
+
+  getServerToolCount(name: string): number {
+    let count = 0;
+    for (const [, serverName] of this.toolsToServer.entries()) {
+      if (serverName === name) count++;
+    }
+    return count;
+  }
+
+  async connectServer(name: string, config: any): Promise<void> {
+    if (config.disabled || name === 'code-intelligence') return;
+
+    let transport: any;
+    if (config.type === 'sse' || config.transportType === 'sse') {
+      transport = new SSEClientTransport(new URL(config.url));
+    } else if (config.type === 'httpStream' || config.transportType === 'httpStream') {
+      transport = new StreamableHTTPClientTransport(new URL(config.url));
+    } else if (config.command) {
+      transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args || [],
+        env: { ...process.env, ...(config.env || {}) },
+      });
+    } else {
+      throw new Error(`Unknown transport for server ${name}`);
+    }
+
+    const client = new Client({ name: 'code-intel-orchestrator', version: '1.0.0' }, { capabilities: {} });
+    await Promise.race([
+      client.connect(transport),
+      new Promise((_, rej) => setTimeout(() => rej(new Error('Connection timeout')), 10000)),
+    ]);
+
+    this.clients.set(name, client);
+    const toolsResult = await client.listTools();
+    for (const tool of (toolsResult.tools || [])) {
+      this.toolsToServer.set(tool.name, name);
+      this.proxiedTools.push({
+        name: tool.name,
+        description: tool.description || '',
+        category: name as any,
+        inputSchema: tool.inputSchema as any,
+      });
+    }
+    this.logger.info({ name, tools: toolsResult.tools?.length ?? 0 }, 'Server connected via config API');
+  }
+
+  async disconnectServer(name: string): Promise<void> {
+    const client = this.clients.get(name);
+    if (client) {
+      try { await client.close(); } catch { /* ok */ }
+      this.clients.delete(name);
+    }
+    for (const [toolName, serverName] of this.toolsToServer.entries()) {
+      if (serverName === name) this.toolsToServer.delete(toolName);
+    }
+    this.proxiedTools = this.proxiedTools.filter(t => t.category !== name);
+  }
+}