@deimoscloud/coreai 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { join as join11, dirname as dirname4 } from "path";
+import { join as join12, dirname as dirname5 } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 
@@ -129,6 +129,9 @@ function configExists(startDir) {
   return findConfigFile(startDir) !== null;
 }
 
+// src/agents/types.ts
+var DEFAULT_AGENT_TOOLS = ["Read", "Write", "Edit", "Bash", "Glob", "Grep"];
+
 // src/agents/loader.ts
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
 import { basename, extname, join as join2 } from "path";
@@ -357,8 +360,24 @@ function resolveAgentDefinition(agent, config, options = {}) {
 // src/agents/compiler.ts
 import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
 import { join as join3, dirname as dirname2 } from "path";
-function generateAgentMarkdown(agent) {
+function buildAgentTools(agent, mcpServers) {
+  const tools = agent.tools ? [...agent.tools] : [...DEFAULT_AGENT_TOOLS];
+  if (mcpServers && mcpServers.length > 0) {
+    for (const server of mcpServers) {
+      tools.push(`mcp__${server}`);
+    }
+  }
+  return tools.join(", ");
+}
+function generateAgentMarkdown(agent, mcpServers) {
   const lines = [];
+  const tools = buildAgentTools(agent, mcpServers);
+  lines.push("---");
+  lines.push(`name: ${agent.role}`);
+  lines.push(`description: ${agent.description.replace(/\n/g, " ").trim()}`);
+  lines.push(`tools: ${tools}`);
+  lines.push("---");
+  lines.push("");
   lines.push(`# ${agent.display_name}`);
   lines.push("");
   lines.push(`**Role:** ${agent.role}`);
@@ -485,9 +504,9 @@ function generateAgentMarkdown(agent) {
 function formatTitle(str) {
   return str.replace(/[_-]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
-function compileAgent(agent, config) {
+function compileAgent(agent, config, mcpServers) {
   const resolved = resolveAgentDefinition(agent, config);
-  return generateAgentMarkdown(resolved);
+  return generateAgentMarkdown(resolved, mcpServers);
 }
 function loadAllAgents(options = {}) {
   const agents2 = /* @__PURE__ */ new Map();
@@ -542,7 +561,7 @@ function compileAgents(config, options = {}) {
       continue;
     }
     try {
-      const markdown = compileAgent(metadata.definition, config);
+      const markdown = compileAgent(metadata.definition, config, options.mcpServers);
       const outputPath = join3(outputDir, `${role}.md`);
       writeFileSync(outputPath, markdown, "utf-8");
       result.compiled.push({
@@ -561,10 +580,222 @@ function compileAgents(config, options = {}) {
   return result;
 }
 
+// src/adapters/mcp/types.ts
+var McpError = class extends Error {
+  constructor(message, code, server, cause) {
+    super(message, { cause });
+    this.code = code;
+    this.server = server;
+    this.name = "McpError";
+  }
+};
+
 // src/adapters/mcp/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
+// src/adapters/mcp/discovery.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname3 } from "path";
+import { homedir } from "os";
+var CONFIG_FILENAMES = ["mcp.json", ".mcp.json", "claude_desktop_config.json"];
+var PROJECT_CONFIG_DIRS = [".claude", ".config", ""];
+function discoverMcpServers(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const includeGlobal = options.includeGlobal ?? true;
+  const additionalPaths = options.additionalPaths ?? [];
+  const servers = [];
+  const seenServers = /* @__PURE__ */ new Set();
+  const configPaths = [];
+  for (const dir of PROJECT_CONFIG_DIRS) {
+    for (const filename of CONFIG_FILENAMES) {
+      const path = dir ? join4(projectRoot, dir, filename) : join4(projectRoot, filename);
+      configPaths.push(path);
+    }
+  }
+  configPaths.push(...additionalPaths);
+  if (includeGlobal) {
+    const homeDir = homedir();
+    const globalPaths = [
+      join4(homeDir, ".config", "claude", "mcp.json"),
+      join4(homeDir, ".claude", "mcp.json"),
+      join4(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+    ];
+    configPaths.push(...globalPaths);
+  }
+  for (const configPath of configPaths) {
+    if (!existsSync4(configPath)) continue;
+    try {
+      const fileServers = loadServersFromFile(configPath);
+      for (const server of fileServers) {
+        if (seenServers.has(server.name)) continue;
+        seenServers.add(server.name);
+        servers.push(server);
+      }
+    } catch (error) {
+      console.warn(
+        `Warning: Failed to load MCP config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return servers;
+}
+function loadServersFromFile(filePath) {
+  if (!existsSync4(filePath)) {
+    throw new McpError(`Config file not found: ${filePath}`, "invalid_config");
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch (error) {
+    throw new McpError(
+      `Invalid JSON in config file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+      "invalid_config",
+      void 0,
+      error instanceof Error ? error : void 0
+    );
+  }
+  return parseServersFromConfig(config, filePath);
+}
+function parseServersFromConfig(config, sourcePath) {
+  const servers = [];
+  if (!config.mcpServers) {
+    return servers;
+  }
+  for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+    try {
+      const validConfig = validateServerConfig(serverConfig, name);
+      if (validConfig.transport === "stdio" && sourcePath) {
+        validConfig.cwd = validConfig.cwd ?? dirname3(sourcePath);
+      }
+      servers.push({
+        name,
+        config: validConfig,
+        enabled: true
+      });
+    } catch (error) {
+      console.warn(
+        `Warning: Invalid server config for "${name}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return servers;
+}
+function validateServerConfig(config, serverName) {
+  if (!config || typeof config !== "object") {
+    throw new McpError(
+      `Server config for "${serverName}" must be an object`,
+      "invalid_config",
+      serverName
+    );
+  }
+  const cfg = config;
+  if ("command" in cfg && typeof cfg.command === "string") {
+    return validateStdioConfig(cfg, serverName);
+  }
+  if ("url" in cfg && typeof cfg.url === "string") {
+    return validateHttpConfig(cfg, serverName);
+  }
+  if ("transport" in cfg) {
+    const transport = cfg.transport;
+    if (transport === "stdio") {
+      return validateStdioConfig(cfg, serverName);
+    }
+    if (transport === "http" || transport === "sse") {
+      return validateHttpConfig(cfg, serverName);
+    }
+    throw new McpError(
+      `Unknown transport type "${transport}" for server "${serverName}"`,
+      "invalid_config",
+      serverName
+    );
+  }
+  throw new McpError(
+    `Server config for "${serverName}" must have either 'command' (stdio) or 'url' (http)`,
+    "invalid_config",
+    serverName
+  );
+}
+function validateStdioConfig(cfg, serverName) {
+  if (!cfg.command || typeof cfg.command !== "string") {
+    throw new McpError(
+      `Server "${serverName}" requires a 'command' string`,
+      "invalid_config",
+      serverName
+    );
+  }
+  const config = {
+    transport: "stdio",
+    command: cfg.command
+  };
+  if (cfg.args !== void 0) {
+    if (!Array.isArray(cfg.args) || !cfg.args.every((a) => typeof a === "string")) {
+      throw new McpError(
+        `Server "${serverName}" 'args' must be an array of strings`,
+        "invalid_config",
+        serverName
+      );
+    }
+    config.args = cfg.args;
+  }
+  if (cfg.env !== void 0) {
+    if (typeof cfg.env !== "object" || cfg.env === null) {
+      throw new McpError(
+        `Server "${serverName}" 'env' must be an object`,
+        "invalid_config",
+        serverName
+      );
+    }
+    config.env = cfg.env;
+  }
+  if (cfg.cwd !== void 0) {
+    if (typeof cfg.cwd !== "string") {
+      throw new McpError(
+        `Server "${serverName}" 'cwd' must be a string`,
+        "invalid_config",
+        serverName
+      );
+    }
+    config.cwd = cfg.cwd;
+  }
+  return config;
+}
+function validateHttpConfig(cfg, serverName) {
+  if (!cfg.url || typeof cfg.url !== "string") {
+    throw new McpError(
+      `Server "${serverName}" requires a 'url' string`,
+      "invalid_config",
+      serverName
+    );
+  }
+  try {
+    new URL(cfg.url);
+  } catch {
+    throw new McpError(
+      `Server "${serverName}" has invalid URL: ${cfg.url}`,
+      "invalid_config",
+      serverName
+    );
+  }
+  const transport = cfg.transport === "sse" ? "sse" : "http";
+  const config = {
+    transport,
+    url: cfg.url
+  };
+  if (cfg.headers !== void 0) {
+    if (typeof cfg.headers !== "object" || cfg.headers === null) {
+      throw new McpError(
+        `Server "${serverName}" 'headers' must be an object`,
+        "invalid_config",
+        serverName
+      );
+    }
+    config.headers = cfg.headers;
+  }
+  return config;
+}
+
 // src/adapters/native/github.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -627,7 +858,7 @@ var DEFAULT_CACHE_CONFIG = {
 
 // src/cache/provider.ts
 import { promises as fs } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
+import { join as join5, dirname as dirname4 } from "path";
 import { createHash } from "crypto";
 function noop() {
 }
@@ -645,10 +876,10 @@ var FileCacheProvider = class {
   index = null;
   constructor(options) {
     this.basePath = options.basePath;
-    this.cachePath = join4(this.basePath, CACHE_PATHS.ROOT);
-    this.contentPath = join4(this.basePath, CACHE_PATHS.CONTENT);
-    this.metadataPath = join4(this.basePath, CACHE_PATHS.METADATA);
-    this.indexPath = join4(this.basePath, CACHE_PATHS.INDEX);
+    this.cachePath = join5(this.basePath, CACHE_PATHS.ROOT);
+    this.contentPath = join5(this.basePath, CACHE_PATHS.CONTENT);
+    this.metadataPath = join5(this.basePath, CACHE_PATHS.METADATA);
+    this.indexPath = join5(this.basePath, CACHE_PATHS.INDEX);
     this.ttl = options.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
     this.maxSize = options.maxSize ?? DEFAULT_CACHE_CONFIG.maxSize;
     this.maxEntries = options.maxEntries ?? DEFAULT_CACHE_CONFIG.maxEntries;
@@ -732,8 +963,8 @@ var FileCacheProvider = class {
     const contentHash = this.hashContent(contentStr);
     const size = Buffer.byteLength(contentStr, "utf-8");
     const safeKey = this.sanitizeKey(key);
-    const contentFile = join4(this.contentPath, `${safeKey}.cache`);
-    const metadataFile = join4(this.metadataPath, `${safeKey}.json`);
+    const contentFile = join5(this.contentPath, `${safeKey}.cache`);
+    const metadataFile = join5(this.metadataPath, `${safeKey}.json`);
     const fullMetadata = {
       key,
       source: metadata.source ?? "custom",
@@ -758,8 +989,8 @@ var FileCacheProvider = class {
       fullMetadata.tags = tags;
     }
     try {
-      await fs.mkdir(dirname3(contentFile), { recursive: true });
-      await fs.mkdir(dirname3(metadataFile), { recursive: true });
+      await fs.mkdir(dirname4(contentFile), { recursive: true });
+      await fs.mkdir(dirname4(metadataFile), { recursive: true });
       await fs.writeFile(contentFile, contentStr, "utf-8");
       await fs.writeFile(metadataFile, JSON.stringify(fullMetadata, null, 2), "utf-8");
       if (this.index) {
@@ -1088,11 +1319,11 @@ var FileCacheProvider = class {
       for (const file of metadataFiles) {
         if (!file.endsWith(".json")) continue;
         try {
-          const metadataPath = join4(this.metadataPath, file);
+          const metadataPath = join5(this.metadataPath, file);
           const content = await fs.readFile(metadataPath, "utf-8");
           const metadata = JSON.parse(content);
           const safeKey = this.sanitizeKey(metadata.key);
-          const contentFile = join4(this.contentPath, `${safeKey}.cache`);
+          const contentFile = join5(this.contentPath, `${safeKey}.cache`);
           await fs.access(contentFile);
           index.entries[metadata.key] = {
             key: metadata.key,
@@ -1400,8 +1631,8 @@ var CacheManager = class {
 };
 
 // src/skills/generator.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
-import { join as join5, basename as basename2 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join6, basename as basename2 } from "path";
 
 // src/skills/templates.ts
 var checkInboxSkill = {
@@ -1975,17 +2206,17 @@ function checkDependencies(skill, config) {
 }
 function loadCustomTemplates(templatesDir) {
   const templates = [];
-  if (!existsSync4(templatesDir)) {
+  if (!existsSync5(templatesDir)) {
     return templates;
   }
   const files = readdirSync2(templatesDir);
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = join5(templatesDir, file);
+    const filePath = join6(templatesDir, file);
     const stat = statSync(filePath);
     if (!stat.isFile()) continue;
     try {
-      const content = readFileSync3(filePath, "utf-8");
+      const content = readFileSync4(filePath, "utf-8");
       const template = parseSkillTemplate(file, content);
       templates.push(template);
     } catch {
@@ -2075,7 +2306,7 @@ function mapIntegrationName(name) {
 }
 function generateSkills(config, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const outputDir = options.outputDir ?? join5(projectRoot, ".claude", "commands");
+  const outputDir = options.outputDir ?? join6(projectRoot, ".claude", "commands");
   const includeCoreSkills = options.includeCoreSkills ?? true;
   const includeOptionalSkills = options.includeOptionalSkills ?? true;
   const overwrite = options.overwrite ?? false;
@@ -2096,14 +2327,14 @@ function generateSkills(config, options = {}) {
   if (includeOptionalSkills) {
     templates.push(...builtInSkills.filter((s) => s.category === "optional"));
   }
-  if (options.customTemplatesDir && existsSync4(options.customTemplatesDir)) {
+  if (options.customTemplatesDir && existsSync5(options.customTemplatesDir)) {
     templates.push(...loadCustomTemplates(options.customTemplatesDir));
   }
   if (options.skills && options.skills.length > 0) {
     const skillsToInclude = options.skills;
     templates = templates.filter((t) => skillsToInclude.includes(t.name));
   }
-  if (!existsSync4(outputDir)) {
+  if (!existsSync5(outputDir)) {
     mkdirSync2(outputDir, { recursive: true });
   }
   for (const template of templates) {
@@ -2120,8 +2351,8 @@ function generateSkills(config, options = {}) {
   return result;
 }
 function generateSkill(template, variables, config, outputDir, overwrite) {
-  const outputPath = join5(outputDir, `${template.name}.md`);
-  if (existsSync4(outputPath) && !overwrite) {
+  const outputPath = join6(outputDir, `${template.name}.md`);
+  if (existsSync5(outputPath) && !overwrite) {
     return {
       name: template.name,
       category: template.category,
@@ -2142,7 +2373,7 @@ function generateSkill(template, variables, config, outputDir, overwrite) {
     };
   }
   const content = substituteVariables(template.content, variables);
-  const isUpdate = existsSync4(outputPath);
+  const isUpdate = existsSync5(outputPath);
   writeFileSync2(outputPath, content, "utf-8");
   return {
     name: template.name,
@@ -2195,15 +2426,15 @@ function formatGenerateResult(result) {
 
 // src/knowledge-library/manager.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
   writeFileSync as writeFileSync3,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync3,
   renameSync,
   statSync as statSync2
 } from "fs";
-import { join as join6, basename as basename3 } from "path";
+import { join as join7, basename as basename3 } from "path";
 var DEFAULT_KNOWLEDGE_LIBRARY_PATH = "KnowledgeLibrary";
 var STANDARD_FILES = {
   context: "context.txt",
@@ -2225,32 +2456,32 @@ var CONTROL_FILES = {
   dependencies: "dependencies.txt"
 };
 function getAgentDirectories(basePath, agentName) {
-  const root = join6(basePath, agentName);
+  const root = join7(basePath, agentName);
   return {
     root,
-    inbox: join6(root, "inbox"),
-    inboxProcessed: join6(root, "inbox", "processed"),
-    outbox: join6(root, "outbox"),
-    context: join6(root, "context"),
-    control: join6(root, "control"),
-    history: join6(root, "history"),
-    tech: join6(root, "tech")
+    inbox: join7(root, "inbox"),
+    inboxProcessed: join7(root, "inbox", "processed"),
+    outbox: join7(root, "outbox"),
+    context: join7(root, "context"),
+    control: join7(root, "control"),
+    history: join7(root, "history"),
+    tech: join7(root, "tech")
   };
 }
 function initKnowledgeLibrary(options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const basePath = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
   const createDefaults = options.createDefaults ?? true;
   const createdDirs = [];
   const createdFiles = [];
   try {
-    if (!existsSync5(basePath)) {
+    if (!existsSync6(basePath)) {
       mkdirSync3(basePath, { recursive: true });
       createdDirs.push(basePath);
     }
     if (createDefaults) {
-      const contextPath = join6(basePath, STANDARD_FILES.context);
-      if (!existsSync5(contextPath)) {
+      const contextPath = join7(basePath, STANDARD_FILES.context);
+      if (!existsSync6(contextPath)) {
         writeFileSync3(
           contextPath,
           `# Project Context
@@ -2272,8 +2503,8 @@ function initKnowledgeLibrary(options = {}) {
         );
         createdFiles.push(contextPath);
       }
-      const architecturePath = join6(basePath, STANDARD_FILES.architecture);
-      if (!existsSync5(architecturePath)) {
+      const architecturePath = join7(basePath, STANDARD_FILES.architecture);
+      if (!existsSync6(architecturePath)) {
         writeFileSync3(
           architecturePath,
           `# Architecture Notes
@@ -2291,8 +2522,8 @@ function initKnowledgeLibrary(options = {}) {
         );
         createdFiles.push(architecturePath);
       }
-      const prdPath = join6(basePath, STANDARD_FILES.prd);
-      if (!existsSync5(prdPath)) {
+      const prdPath = join7(basePath, STANDARD_FILES.prd);
+      if (!existsSync6(prdPath)) {
         writeFileSync3(
           prdPath,
           `# Product Requirements Document
@@ -2330,12 +2561,12 @@ function initKnowledgeLibrary(options = {}) {
 }
 function initAgentKnowledgeLibrary(agentName, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const basePath = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
   const createDefaults = options.createDefaults ?? true;
   const createdDirs = [];
   const createdFiles = [];
   try {
-    if (!existsSync5(basePath)) {
+    if (!existsSync6(basePath)) {
       const baseResult = initKnowledgeLibrary(options);
       if (!baseResult.success) {
         return baseResult;
@@ -2345,15 +2576,15 @@ function initAgentKnowledgeLibrary(agentName, options = {}) {
     }
     const dirs = getAgentDirectories(basePath, agentName);
     for (const dir of AGENT_DIRECTORIES) {
-      const dirPath = join6(dirs.root, dir);
-      if (!existsSync5(dirPath)) {
+      const dirPath = join7(dirs.root, dir);
+      if (!existsSync6(dirPath)) {
         mkdirSync3(dirPath, { recursive: true });
         createdDirs.push(dirPath);
       }
     }
     if (createDefaults) {
-      const currentContextPath = join6(dirs.context, "current.txt");
-      if (!existsSync5(currentContextPath)) {
+      const currentContextPath = join7(dirs.context, "current.txt");
+      if (!existsSync6(currentContextPath)) {
         writeFileSync3(
           currentContextPath,
           `# ${agentName} Current Context
@@ -2370,8 +2601,8 @@ function initAgentKnowledgeLibrary(agentName, options = {}) {
         );
         createdFiles.push(currentContextPath);
       }
-      const objectivesPath = join6(dirs.control, CONTROL_FILES.objectives);
-      if (!existsSync5(objectivesPath)) {
+      const objectivesPath = join7(dirs.control, CONTROL_FILES.objectives);
+      if (!existsSync6(objectivesPath)) {
         writeFileSync3(
           objectivesPath,
           `# ${agentName} Objectives
@@ -2386,8 +2617,8 @@ function initAgentKnowledgeLibrary(agentName, options = {}) {
         );
         createdFiles.push(objectivesPath);
       }
-      const decisionsPath = join6(dirs.control, CONTROL_FILES.decisions);
-      if (!existsSync5(decisionsPath)) {
+      const decisionsPath = join7(dirs.control, CONTROL_FILES.decisions);
+      if (!existsSync6(decisionsPath)) {
         writeFileSync3(
           decisionsPath,
           `# ${agentName} Decision Log
@@ -2405,8 +2636,8 @@ Format:
         );
         createdFiles.push(decisionsPath);
       }
-      const dependenciesPath = join6(dirs.control, CONTROL_FILES.dependencies);
-      if (!existsSync5(dependenciesPath)) {
+      const dependenciesPath = join7(dirs.control, CONTROL_FILES.dependencies);
+      if (!existsSync6(dependenciesPath)) {
         writeFileSync3(
           dependenciesPath,
           `# ${agentName} Dependencies
@@ -2440,20 +2671,20 @@ Last Updated: ${(/* @__PURE__ */ new Date()).toISOString()}
 }
 function agentKnowledgeLibraryExists(agentName, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const basePath = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
-  const agentRoot = join6(basePath, agentName);
-  return existsSync5(agentRoot) && existsSync5(join6(agentRoot, "inbox"));
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const agentRoot = join7(basePath, agentName);
+  return existsSync6(agentRoot) && existsSync6(join7(agentRoot, "inbox"));
 }
 function getAgentKnowledgeState(agentName, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const basePath = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
   const dirs = getAgentDirectories(basePath, agentName);
   const initialized = agentKnowledgeLibraryExists(agentName, options);
   const pendingMessages = initialized ? readInboxMessages(agentName, options) : [];
   let context;
-  const currentContextPath = join6(dirs.context, "current.txt");
-  if (existsSync5(currentContextPath)) {
-    const content = readFileSync4(currentContextPath, "utf-8");
+  const currentContextPath = join7(dirs.context, "current.txt");
+  if (existsSync6(currentContextPath)) {
+    const content = readFileSync5(currentContextPath, "utf-8");
     context = parseContextFile(content);
   }
   const state = {
@@ -2538,16 +2769,16 @@ function parseMessageFrontmatter(content) {
 }
 function readInboxMessages(agentName, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const basePath = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
   const dirs = getAgentDirectories(basePath, agentName);
   const messages = [];
-  if (existsSync5(dirs.inbox)) {
+  if (existsSync6(dirs.inbox)) {
     const files = readdirSync3(dirs.inbox).filter(
-      (f) => f.endsWith(".md") && statSync2(join6(dirs.inbox, f)).isFile()
+      (f) => f.endsWith(".md") && statSync2(join7(dirs.inbox, f)).isFile()
     );
     for (const file of files) {
-      const filePath = join6(dirs.inbox, file);
-      const rawContent = readFileSync4(filePath, "utf-8");
+      const filePath = join7(dirs.inbox, file);
+      const rawContent = readFileSync5(filePath, "utf-8");
       const { metadata, body } = parseMessageFrontmatter(rawContent);
       if (options.type && metadata.type !== options.type) continue;
       if (options.from && metadata.from !== options.from) continue;
@@ -2561,13 +2792,13 @@ function readInboxMessages(agentName, options = {}) {
       });
     }
   }
-  if (options.includeProcessed && existsSync5(dirs.inboxProcessed)) {
+  if (options.includeProcessed && existsSync6(dirs.inboxProcessed)) {
     const files = readdirSync3(dirs.inboxProcessed).filter(
-      (f) => f.endsWith(".md") && statSync2(join6(dirs.inboxProcessed, f)).isFile()
+      (f) => f.endsWith(".md") && statSync2(join7(dirs.inboxProcessed, f)).isFile()
     );
     for (const file of files) {
-      const filePath = join6(dirs.inboxProcessed, file);
-      const rawContent = readFileSync4(filePath, "utf-8");
+      const filePath = join7(dirs.inboxProcessed, file);
+      const rawContent = readFileSync5(filePath, "utf-8");
       const { metadata, body } = parseMessageFrontmatter(rawContent);
       if (options.type && metadata.type !== options.type) continue;
       if (options.from && metadata.from !== options.from) continue;
@@ -2593,23 +2824,23 @@ function readInboxMessages(agentName, options = {}) {
 }
 function getKnowledgeLibraryState(options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const basePath = join6(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
-  if (!existsSync5(basePath)) {
+  const basePath = join7(projectRoot, options.basePath ?? DEFAULT_KNOWLEDGE_LIBRARY_PATH);
+  if (!existsSync6(basePath)) {
     return null;
   }
   const agents2 = [];
   const entries = readdirSync3(basePath);
   for (const entry of entries) {
-    const entryPath = join6(basePath, entry);
-    if (statSync2(entryPath).isDirectory() && existsSync5(join6(entryPath, "inbox"))) {
+    const entryPath = join7(basePath, entry);
+    if (statSync2(entryPath).isDirectory() && existsSync6(join7(entryPath, "inbox"))) {
       agents2.push(entry);
     }
   }
   return {
     basePath,
-    contextPath: join6(basePath, STANDARD_FILES.context),
-    architecturePath: join6(basePath, STANDARD_FILES.architecture),
-    prdPath: join6(basePath, STANDARD_FILES.prd),
+    contextPath: join7(basePath, STANDARD_FILES.context),
+    architecturePath: join7(basePath, STANDARD_FILES.architecture),
+    prdPath: join7(basePath, STANDARD_FILES.prd),
     agents: agents2
   };
 }
@@ -2618,13 +2849,13 @@ function getKnowledgeLibraryState(options = {}) {
 var VERSION = "0.1.0";
 
 // src/cli/commands/cache.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function getCachePath(options) {
   if (options.cachePath) {
     return options.cachePath;
   }
   const root = options.projectRoot ?? process.cwd();
-  return join7(root, CACHE_PATHS.base);
+  return join8(root, CACHE_PATHS.base);
 }
 async function cacheStatus(options = {}) {
   const cachePath = getCachePath(options);
@@ -2752,7 +2983,7 @@ function formatCacheStatus(result) {
 }
 
 // src/cli/commands/sync.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function createPlaceholderFetcher(source) {
   return {
     async fetch(url) {
@@ -2770,7 +3001,7 @@ function getCachePath2(options) {
     return options.cachePath;
   }
   const root = options.projectRoot ?? process.cwd();
-  return join8(root, CACHE_PATHS.base);
+  return join9(root, CACHE_PATHS.base);
 }
 async function sync(options = {}) {
   const cachePath = getCachePath2(options);
@@ -2887,8 +3118,8 @@ function formatSyncResult(result) {
 }
 
 // src/cli/commands/init.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
-import { join as join9, basename as basename4 } from "path";
+import { existsSync as existsSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join10, basename as basename4 } from "path";
 import { execSync } from "child_process";
 function detectGitInfo() {
   try {
@@ -2915,10 +3146,10 @@ function detectGitInfo() {
   }
 }
 function detectProjectName(projectRoot) {
-  const packageJsonPath = join9(projectRoot, "package.json");
-  if (existsSync6(packageJsonPath)) {
+  const packageJsonPath = join10(projectRoot, "package.json");
+  if (existsSync7(packageJsonPath)) {
     try {
-      const content = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
+      const content = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
       if (content.name) {
         return content.name;
       }
@@ -2976,13 +3207,13 @@ integrations:
 }
 function createDirectories(projectRoot) {
   const dirs = [
-    join9(projectRoot, "coreai", "agents"),
-    join9(projectRoot, "coreai", "commands"),
-    join9(projectRoot, ".coreai", "cache")
+    join10(projectRoot, "coreai", "agents"),
+    join10(projectRoot, "coreai", "commands"),
+    join10(projectRoot, ".coreai", "cache")
   ];
   const created = [];
   for (const dir of dirs) {
-    if (!existsSync6(dir)) {
+    if (!existsSync7(dir)) {
       mkdirSync4(dir, { recursive: true });
       created.push(dir);
     }
@@ -3001,7 +3232,7 @@ function init(options = {}) {
   const name = options.name ?? detectProjectName(projectRoot);
   const type = options.type ?? "software";
   const configContent = generateConfigYaml({ name, type, gitInfo });
-  const configPath = join9(projectRoot, "coreai.config.yaml");
+  const configPath = join10(projectRoot, "coreai.config.yaml");
   try {
     writeFileSync4(configPath, configContent, "utf-8");
   } catch (error) {
@@ -3093,6 +3324,24 @@ function build(options = {}) {
     const agentsList = options.agents;
     compileOptions.filter = (agent) => agentsList.includes(agent.role);
   }
+  const includeMcpServers = options.mcpServers ?? true;
+  if (includeMcpServers !== false) {
+    try {
+      if (Array.isArray(includeMcpServers)) {
+        compileOptions.mcpServers = includeMcpServers;
+      } else {
+        const discoveredServers = discoverMcpServers({
+          projectRoot,
+          includeGlobal: false
+          // Only use project-level MCP config
+        });
+        if (discoveredServers.length > 0) {
+          compileOptions.mcpServers = discoveredServers.map((s) => s.name);
+        }
+      }
+    } catch {
+    }
+  }
   try {
     const result = compileAgents(config, compileOptions);
     if (result.errors.length > 0) {
@@ -3122,7 +3371,8 @@ function build(options = {}) {
       result,
       config,
       warnings: warnings.length > 0 ? warnings : void 0,
-      knowledgeLibraryInitialized
+      knowledgeLibraryInitialized,
+      mcpServers: compileOptions.mcpServers
     };
   } catch (error) {
     return {
@@ -3188,6 +3438,10 @@ function formatBuildResult(result) {
     }
     lines.push("");
   }
+  if (result.mcpServers && result.mcpServers.length > 0) {
+    lines.push(`MCP tools included: ${result.mcpServers.map((s) => `mcp__${s}`).join(", ")}`);
+    lines.push("");
+  }
   if (result.knowledgeLibraryInitialized && result.knowledgeLibraryInitialized.length > 0) {
     lines.push(
       `KnowledgeLibrary initialized for ${result.knowledgeLibraryInitialized.length} agent(s):`
@@ -3202,8 +3456,8 @@ function formatBuildResult(result) {
 }
 
 // src/cli/commands/validate.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join11 } from "path";
 function validateConfig2(projectRoot) {
   const issues = [];
   if (!configExists(projectRoot)) {
@@ -3238,7 +3492,7 @@ function validateConfig2(projectRoot) {
 }
 function validateAgents(config, coreAgentsDir, projectRoot) {
   const issues = [];
-  const customAgentsDir = join10(projectRoot, "coreai", "agents");
+  const customAgentsDir = join11(projectRoot, "coreai", "agents");
   let availableAgents;
   try {
     availableAgents = loadAllAgents({
@@ -3287,8 +3541,8 @@ function validateDirectories(projectRoot) {
     { path: ".claude/agents", description: "Compiled agents output" }
   ];
   for (const dir of requiredDirs) {
-    const fullPath = join10(projectRoot, dir.path);
-    if (!existsSync7(fullPath)) {
+    const fullPath = join11(projectRoot, dir.path);
+    if (!existsSync8(fullPath)) {
       issues.push({
         level: "warning",
         category: "directories",
@@ -3298,8 +3552,8 @@ function validateDirectories(projectRoot) {
     }
   }
   for (const dir of optionalDirs) {
-    const fullPath = join10(projectRoot, dir.path);
-    if (!existsSync7(fullPath)) {
+    const fullPath = join11(projectRoot, dir.path);
+    if (!existsSync8(fullPath)) {
       issues.push({
         level: "info",
         category: "directories",
@@ -3345,7 +3599,7 @@ function validateIntegrations(config) {
 }
 function validate(options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const coreAgentsDir = options.coreAgentsDir ?? join10(projectRoot, "node_modules", "@coreai", "cli", "agents");
+  const coreAgentsDir = options.coreAgentsDir ?? join11(projectRoot, "node_modules", "@coreai", "cli", "agents");
   const checkAgents = options.checkAgents ?? true;
   const checkDirs = options.checkDirs ?? true;
   const allIssues = [];
@@ -3742,9 +3996,9 @@ function formatStatusResult(result) {
 
 // src/cli/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname4(__filename);
+var __dirname = dirname5(__filename);
 function getCoreAgentsPath() {
-  return join11(__dirname, "..", "..", "agents");
+  return join12(__dirname, "..", "..", "agents");
 }
 var program = new Command();
 program.name("coreai").description("A configurable, team-ready AI agent orchestration platform").version(VERSION, "-v, --version", "output the current version");
@@ -3823,7 +4077,7 @@ program.command("validate").description("Validate configuration and project setu
 var agents = program.command("agents").description("Manage agent definitions");
 agents.command("list").description("List available agents").option("--core", "show only core agents").option("--custom", "show only custom agents").action((options) => {
   try {
-    const customAgentsDir = join11(process.cwd(), "coreai", "agents");
+    const customAgentsDir = join12(process.cwd(), "coreai", "agents");
     const allAgents = loadAllAgents({
       coreAgentsDir: getCoreAgentsPath(),
       customAgentsDir
@@ -3877,7 +4131,7 @@ agents.command("list").description("List available agents").option("--core", "sh
 });
 agents.command("show <name>").description("Show details for a specific agent").option("--markdown", "output as compiled markdown").option("--json", "output as JSON").action((name, options) => {
   try {
-    const customAgentsDir = join11(process.cwd(), "coreai", "agents");
+    const customAgentsDir = join12(process.cwd(), "coreai", "agents");
     const allAgents = loadAllAgents({
       coreAgentsDir: getCoreAgentsPath(),
       customAgentsDir