@intellectronica/ruler 0.3.42 → 0.3.44

package/dist/core/SkillsProcessor.js

@@ -54,6 +54,7 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const constants_1 = require("../constants");
 const SkillsUtils_1 = require("./SkillsUtils");
+const FileSystemUtils_1 = require("./FileSystemUtils");
 /**
  * Discovers skills in the project's .ruler/skills directory.
  * Returns discovered skills and any validation warnings.
@@ -102,7 +103,8 @@ async function getSkillsGitignorePaths(projectRoot, agents) {
         factory: FACTORY_SKILLS_PATH,
         antigravity: ANTIGRAVITY_SKILLS_PATH,
     };
-    return Array.from(selectedTargets).map((target) => path.join(projectRoot, targetPaths[target]));
+    const pathSet = new Set(Array.from(selectedTargets).map((target) => path.join(projectRoot, targetPaths[target])));
+    return Array.from(pathSet);
 }
 /**
  * Module-level state to track if experimental warning has been shown.
@@ -137,7 +139,7 @@ const SKILL_TARGET_TO_IDENTIFIERS = new Map([
     ['factory', ['factory']],
     ['antigravity', ['antigravity']],
 ]);
-const SKILL_TARGET_PATHS = [
+const SKILL_TARGET_PATHS = Array.from(new Set([
     constants_1.CLAUDE_SKILLS_PATH,
     constants_1.CODEX_SKILLS_PATH,
     constants_1.OPENCODE_SKILLS_PATH,
@@ -151,7 +153,7 @@ const SKILL_TARGET_PATHS = [
     constants_1.WINDSURF_SKILLS_PATH,
     constants_1.FACTORY_SKILLS_PATH,
     constants_1.ANTIGRAVITY_SKILLS_PATH,
-];
+]));
 function getSelectedSkillTargets(agents) {
     const selectedIdentifiers = new Set(agents
         .filter((agent) => agent.supportsNativeSkills?.())
@@ -185,10 +187,14 @@ async function cleanupSkillsDirectory(projectRoot, relativePath, dryRun, verbose
         (0, constants_1.logVerboseInfo)(`DRY RUN: Would remove ${relativePath}`, verbose, dryRun);
         return;
     }
+    await (0, FileSystemUtils_1.assertManagedPathInsideRoot)(targetPath, projectRoot, 'Refusing to remove skills directory through symlinked path');
     await fs.rm(targetPath, { recursive: true, force: true });
     (0, constants_1.logVerboseInfo)(`Removed ${relativePath} (skills disabled)`, verbose, dryRun);
 }
-async function createTempSkillsDir(parentDir) {
+async function createTempSkillsDir(parentDir, containmentRoot) {
+    if (containmentRoot) {
+        await (0, FileSystemUtils_1.assertManagedPathInsideRoot)(parentDir, containmentRoot, 'Refusing to create temporary skills directory through symlinked path');
+    }
     return fs.mkdtemp(path.join(parentDir, 'skills.tmp-'));
 }
 const TRANSIENT_RENAME_ERROR_CODES = new Set(['EPERM', 'EBUSY', 'ENOTEMPTY']);
@@ -204,7 +210,10 @@ function isTransientRenameError(error) {
 function wait(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function replaceSkillsDirectory(tempDir, targetDir, fsOps = fs) {
+async function replaceSkillsDirectory(tempDir, targetDir, fsOps = fs, containmentRoot) {
+    if (containmentRoot) {
+        await (0, FileSystemUtils_1.assertManagedPathInsideRoot)(targetDir, containmentRoot, 'Refusing to replace skills directory through symlinked path');
+    }
     let lastError;
     for (let attempt = 1; attempt <= RENAME_RETRY_ATTEMPTS; attempt += 1) {
         try {
@@ -362,7 +371,7 @@ async function propagateSkillsForClaude(projectRoot, options) {
     // Ensure .claude directory exists
     await fs.mkdir(claudeDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(claudeDir);
+    const tempDir = await createTempSkillsDir(claudeDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -375,7 +384,7 @@ async function propagateSkillsForClaude(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, claudeSkillsPath);
+        await replaceSkillsDirectory(tempDir, claudeSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -390,14 +399,14 @@ async function propagateSkillsForClaude(projectRoot, options) {
     return [];
 }
 /**
- * Propagates skills for OpenAI Codex CLI by copying .ruler/skills to .codex/skills.
+ * Propagates skills for OpenAI Codex CLI by copying .ruler/skills to .agents/skills.
  * Uses atomic replace to ensure safe overwriting of existing skills.
  * Returns dry-run steps if dryRun is true, otherwise returns empty array.
  */
 async function propagateSkillsForCodex(projectRoot, options) {
     const skillsDir = path.join(projectRoot, constants_1.RULER_SKILLS_PATH);
-    const codexSkillsPath = path.join(projectRoot, constants_1.CODEX_SKILLS_PATH);
-    const codexDir = path.dirname(codexSkillsPath);
+    const agentsSkillsPath = path.join(projectRoot, constants_1.CODEX_SKILLS_PATH);
+    const agentsDir = path.dirname(agentsSkillsPath);
     // Check if source skills directory exists
     try {
         await fs.access(skillsDir);
@@ -409,23 +418,23 @@ async function propagateSkillsForCodex(projectRoot, options) {
     if (options.dryRun) {
         return [`Copy skills from ${constants_1.RULER_SKILLS_PATH} to ${constants_1.CODEX_SKILLS_PATH}`];
     }
-    // Ensure .codex directory exists
-    await fs.mkdir(codexDir, { recursive: true });
+    // Ensure .agents directory exists
+    await fs.mkdir(agentsDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(codexDir);
+    const tempDir = await createTempSkillsDir(agentsDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
         // Atomically replace the target
         // First, remove existing target if it exists
         try {
-            await fs.rm(codexSkillsPath, { recursive: true, force: true });
+            await fs.rm(agentsSkillsPath, { recursive: true, force: true });
         }
         catch {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, codexSkillsPath);
+        await replaceSkillsDirectory(tempDir, agentsSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -462,7 +471,7 @@ async function propagateSkillsForOpenCode(projectRoot, options) {
     // Ensure .opencode directory exists
     await fs.mkdir(opencodeDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(opencodeDir);
+    const tempDir = await createTempSkillsDir(opencodeDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -475,7 +484,7 @@ async function propagateSkillsForOpenCode(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, opencodeSkillsPath);
+        await replaceSkillsDirectory(tempDir, opencodeSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -512,7 +521,7 @@ async function propagateSkillsForPi(projectRoot, options) {
     // Ensure .pi directory exists
     await fs.mkdir(piDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(piDir);
+    const tempDir = await createTempSkillsDir(piDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -525,7 +534,7 @@ async function propagateSkillsForPi(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, piSkillsPath);
+        await replaceSkillsDirectory(tempDir, piSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -562,7 +571,7 @@ async function propagateSkillsForGoose(projectRoot, options) {
     // Ensure .agents directory exists
     await fs.mkdir(gooseDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(gooseDir);
+    const tempDir = await createTempSkillsDir(gooseDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -575,7 +584,7 @@ async function propagateSkillsForGoose(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, gooseSkillsPath);
+        await replaceSkillsDirectory(tempDir, gooseSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -612,7 +621,7 @@ async function propagateSkillsForVibe(projectRoot, options) {
     // Ensure .vibe directory exists
     await fs.mkdir(vibeDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(vibeDir);
+    const tempDir = await createTempSkillsDir(vibeDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -625,7 +634,7 @@ async function propagateSkillsForVibe(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, vibeSkillsPath);
+        await replaceSkillsDirectory(tempDir, vibeSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -662,7 +671,7 @@ async function propagateSkillsForRoo(projectRoot, options) {
     // Ensure .roo directory exists
     await fs.mkdir(rooDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(rooDir);
+    const tempDir = await createTempSkillsDir(rooDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -675,7 +684,7 @@ async function propagateSkillsForRoo(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, rooSkillsPath);
+        await replaceSkillsDirectory(tempDir, rooSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -712,7 +721,7 @@ async function propagateSkillsForGemini(projectRoot, options) {
     // Ensure .gemini directory exists
     await fs.mkdir(geminiDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(geminiDir);
+    const tempDir = await createTempSkillsDir(geminiDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -725,7 +734,7 @@ async function propagateSkillsForGemini(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, geminiSkillsPath);
+        await replaceSkillsDirectory(tempDir, geminiSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -758,7 +767,7 @@ async function propagateSkillsForJunie(projectRoot, options) {
         return [`Copy skills from ${constants_1.RULER_SKILLS_PATH} to ${constants_1.JUNIE_SKILLS_PATH}`];
     }
     await fs.mkdir(junieDir, { recursive: true });
-    const tempDir = await createTempSkillsDir(junieDir);
+    const tempDir = await createTempSkillsDir(junieDir, projectRoot);
     try {
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
         try {
@@ -767,7 +776,7 @@ async function propagateSkillsForJunie(projectRoot, options) {
         catch {
             // Target didn't exist, that's fine
         }
-        await replaceSkillsDirectory(tempDir, junieSkillsPath);
+        await replaceSkillsDirectory(tempDir, junieSkillsPath, fs, projectRoot);
     }
     catch (error) {
         try {
@@ -803,7 +812,7 @@ async function propagateSkillsForCursor(projectRoot, options) {
     // Ensure .cursor directory exists
     await fs.mkdir(cursorDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(cursorDir);
+    const tempDir = await createTempSkillsDir(cursorDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -816,7 +825,7 @@ async function propagateSkillsForCursor(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, cursorSkillsPath);
+        await replaceSkillsDirectory(tempDir, cursorSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -853,7 +862,7 @@ async function propagateSkillsForWindsurf(projectRoot, options) {
     // Ensure .windsurf directory exists
     await fs.mkdir(windsurfDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(windsurfDir);
+    const tempDir = await createTempSkillsDir(windsurfDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -866,7 +875,7 @@ async function propagateSkillsForWindsurf(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, windsurfSkillsPath);
+        await replaceSkillsDirectory(tempDir, windsurfSkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -903,7 +912,7 @@ async function propagateSkillsForFactory(projectRoot, options) {
     // Ensure .factory directory exists
     await fs.mkdir(factoryDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(factoryDir);
+    const tempDir = await createTempSkillsDir(factoryDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -916,7 +925,7 @@ async function propagateSkillsForFactory(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, factorySkillsPath);
+        await replaceSkillsDirectory(tempDir, factorySkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error
@@ -955,7 +964,7 @@ async function propagateSkillsForAntigravity(projectRoot, options) {
     // Ensure .agent directory exists
     await fs.mkdir(antigravityDir, { recursive: true });
     // Use atomic replace: copy to temp, then rename
-    const tempDir = await createTempSkillsDir(antigravityDir);
+    const tempDir = await createTempSkillsDir(antigravityDir, projectRoot);
     try {
         // Copy to temp directory
         await (0, SkillsUtils_1.copySkillsDirectory)(skillsDir, tempDir);
@@ -968,7 +977,7 @@ async function propagateSkillsForAntigravity(projectRoot, options) {
             // Target didn't exist, that's fine
         }
         // Rename temp to target
-        await replaceSkillsDirectory(tempDir, antigravitySkillsPath);
+        await replaceSkillsDirectory(tempDir, antigravitySkillsPath, fs, projectRoot);
     }
     catch (error) {
         // Clean up temp directory on error

package/dist/core/SkillsUtils.js

@@ -137,7 +137,10 @@ function formatValidationWarnings(warnings) {
  * Recursively copies a directory and all its contents.
  */
 async function copyRecursive(src, dest) {
-    const stat = await fs.stat(src);
+    const stat = await fs.lstat(src);
+    if (stat.isSymbolicLink()) {
+        return;
+    }
     if (stat.isDirectory()) {
         await fs.mkdir(dest, { recursive: true });
         const entries = await fs.readdir(src, { withFileTypes: true });

package/dist/core/SubagentsProcessor.js

@@ -48,6 +48,7 @@ const yaml = __importStar(require("js-yaml"));
 const toml_1 = require("@iarna/toml");
 const constants_1 = require("../constants");
 const SubagentsUtils_1 = require("./SubagentsUtils");
+const FileSystemUtils_1 = require("./FileSystemUtils");
 /**
  * Discovers subagent definitions in `.ruler/agents/`.
  * Each `.md` file is parsed for YAML frontmatter (name, description, …).
@@ -173,8 +174,9 @@ function ensureBodyFormatting(body) {
  * Stages files into a temp directory and atomically swaps it into place.
  * Mirrors the pattern used by SkillsProcessor for safe overwriting.
  */
-async function writeAgentsDirectoryAtomic(targetDir, files) {
+async function writeAgentsDirectoryAtomic(targetDir, files, projectRoot) {
     const parent = path.dirname(targetDir);
+    await (0, FileSystemUtils_1.assertManagedPathInsideRoot)(targetDir, projectRoot, 'Refusing to replace subagents directory through symlinked path');
     await fs.mkdir(parent, { recursive: true });
     const tempDir = path.join(parent, `agents.tmp-${Date.now()}`);
     await fs.mkdir(tempDir, { recursive: true });
@@ -310,7 +312,7 @@ async function propagateSubagentsForClaude(projectRoot, subagents, options) {
         name: getSourceRelativeMdPath(s),
         content: buildClaudeFile(s),
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 async function propagateSubagentsForCursor(projectRoot, subagents, options) {
@@ -324,7 +326,7 @@ async function propagateSubagentsForCursor(projectRoot, subagents, options) {
         name: getSourceRelativeMdPath(s),
         content: buildCursorFile(s),
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 async function propagateSubagentsForCodex(projectRoot, subagents, options) {
@@ -338,7 +340,7 @@ async function propagateSubagentsForCodex(projectRoot, subagents, options) {
         name: withExtension(getSourceRelativeMdPath(s), '.toml'),
         content: buildCodexFile(s),
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 async function propagateSubagentsForCopilot(projectRoot, subagents, options) {
@@ -361,7 +363,7 @@ async function propagateSubagentsForCopilot(projectRoot, subagents, options) {
         name: getSourceRelativeMdPath(s),
         content: buildCopilotFile(s, false, verbose).content,
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 /* ------------------------------------------------------------------ */
@@ -379,6 +381,7 @@ async function cleanupSubagentsDir(projectRoot, relPath, dryRun, verbose) {
         (0, constants_1.logVerboseInfo)(`DRY RUN: Would remove ${relPath}`, verbose, dryRun);
         return;
     }
+    await (0, FileSystemUtils_1.assertManagedPathInsideRoot)(target, projectRoot, 'Refusing to remove subagents directory through symlinked path');
     await fs.rm(target, { recursive: true, force: true });
     (0, constants_1.logVerboseInfo)(`Removed ${relPath} (subagents disabled)`, verbose, dryRun);
 }

package/dist/core/UnifiedConfigLoader.js

@@ -36,10 +36,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadUnifiedConfig = loadUnifiedConfig;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const toml_1 = require("@iarna/toml");
 const hash_1 = require("./hash");
 const RuleProcessor_1 = require("./RuleProcessor");
 const FileSystemUtils = __importStar(require("./FileSystemUtils"));
+const KNOWN_MCP_SERVER_FIELDS = new Set([
+    'type',
+    'command',
+    'args',
+    'env',
+    'url',
+    'headers',
+    'timeout',
+]);
+function copyAdditionalMcpServerFields(def) {
+    return Object.fromEntries(Object.entries(def).filter(([key]) => !KNOWN_MCP_SERVER_FIELDS.has(key)));
+}
+async function resolveImplicitTomlFile(projectRoot, rulerDir, checkGlobal) {
+    const localTomlFile = path.join(rulerDir, 'ruler.toml');
+    if (await fileExists(localTomlFile)) {
+        return localTomlFile;
+    }
+    const projectTomlFile = path.join(projectRoot, '.ruler', 'ruler.toml');
+    if (path.resolve(projectTomlFile) !== path.resolve(localTomlFile) &&
+        (await fileExists(projectTomlFile))) {
+        return projectTomlFile;
+    }
+    if (!checkGlobal) {
+        return undefined;
+    }
+    const xdgConfigDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const globalTomlFile = path.join(xdgConfigDir, 'ruler', 'ruler.toml');
+    if (path.resolve(globalTomlFile) !== path.resolve(localTomlFile) &&
+        (await fileExists(globalTomlFile))) {
+        return globalTomlFile;
+    }
+    return undefined;
+}
+async function fileExists(filePath) {
+    try {
+        await fs_1.promises.access(filePath);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return false;
+        }
+        throw err;
+    }
+}
 async function loadUnifiedConfig(options) {
     // Resolve the effective .ruler directory (local or global), mirroring the main loader behavior
     const resolvedRulerDir = (await FileSystemUtils.findRulerDir(options.projectRoot, options.checkGlobal ?? true)) || path.join(options.projectRoot, '.ruler');
@@ -54,15 +100,14 @@ async function loadUnifiedConfig(options) {
     let tomlRaw = {};
     const tomlFile = options.configPath
         ? path.resolve(options.configPath)
-        : path.join(meta.rulerDir, 'ruler.toml');
-    try {
-        const text = await fs_1.promises.readFile(tomlFile, 'utf8');
-        tomlRaw = text.trim() ? (0, toml_1.parse)(text) : {};
-        meta.configFile = tomlFile;
-    }
-    catch (err) {
-        if (options.configPath ||
-            err.code !== 'ENOENT') {
+        : await resolveImplicitTomlFile(options.projectRoot, meta.rulerDir, options.checkGlobal ?? true);
+    if (tomlFile) {
+        try {
+            const text = await fs_1.promises.readFile(tomlFile, 'utf8');
+            tomlRaw = text.trim() ? (0, toml_1.parse)(text) : {};
+            meta.configFile = tomlFile;
+        }
+        catch (err) {
             diagnostics.push({
                 severity: options.configPath ? 'error' : 'warning',
                 code: 'TOML_READ_ERROR',
@@ -169,7 +214,7 @@ async function loadUnifiedConfig(options) {
                 if (!def || typeof def !== 'object')
                     continue;
                 const serverDef = def;
-                const server = {};
+                const server = copyAdditionalMcpServerFields(serverDef);
                 // Parse command and args
                 if (typeof serverDef.command === 'string') {
                     server.command = serverDef.command;
@@ -319,7 +364,7 @@ async function loadUnifiedConfig(options) {
                         });
                         continue;
                     }
-                    const server = {};
+                    const server = copyAdditionalMcpServerFields(def);
                     if (typeof def.command === 'string')
                         server.command = def.command;
                     if (Array.isArray(def.command))
@@ -337,6 +382,46 @@ async function loadUnifiedConfig(options) {
                     if (typeof def.timeout === 'number') {
                         server.timeout = def.timeout;
                     }
+                    const hasCommand = !!server.command;
+                    const hasUrl = !!server.url;
+                    if (!hasCommand && !hasUrl) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_INVALID_SERVER',
+                            message: `MCP server '${name}' must have at least one of command or url`,
+                            file: mcpFile,
+                        });
+                        continue;
+                    }
+                    if (hasCommand && hasUrl) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_FIELD_CONFLICT',
+                            message: `MCP server '${name}' has both command and url - using url (remote)`,
+                            file: mcpFile,
+                        });
+                    }
+                    if (hasCommand && server.headers) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_FIELD_CONFLICT',
+                            message: `MCP server '${name}' has headers with command (should be used with url only)`,
+                            file: mcpFile,
+                        });
+                    }
+                    if (hasUrl && server.env) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_FIELD_CONFLICT',
+                            message: `MCP server '${name}' has env with url (should be used with command only)`,
+                            file: mcpFile,
+                        });
+                    }
+                    if (hasCommand && hasUrl) {
+                        delete server.command;
+                        delete server.args;
+                        delete server.env;
+                    }
                     // Derive type
                     if (server.url)
                         server.type = 'remote';

package/dist/core/UnifiedConfigTypes.d.ts

@@ -35,6 +35,7 @@ export interface AgentTomlConfig {
     outputPathInstructions?: string;
     outputPathConfig?: string;
     mcp?: McpConfig;
+    mcpServers?: Record<string, McpServerDef>;
     source: AgentConfigSourceMeta;
 }
 export interface AgentConfigSourceMeta {
@@ -61,7 +62,8 @@ export interface McpBundle {
     hash: string;
 }
 export interface McpServerDef {
-    type?: 'stdio' | 'local' | 'remote';
+    [key: string]: unknown;
+    type?: string;
     command?: string;
     args?: string[];
     env?: Record<string, string>;

package/dist/core/agent-selection.js

@@ -22,11 +22,15 @@ function agentMatchesFilter(agent, filter, validAgentIdentifiers) {
 function resolveSelectedAgents(config, allAgents) {
     // CLI --agents > config.default_agents > per-agent.enabled flags > default all
     let selected = allAgents;
+    const validAgentIdentifiers = new Set(allAgents.map((agent) => agent.getIdentifier()));
+    const validAgentNames = new Set(allAgents.map((agent) => agent.getName().toLowerCase()));
+    const invalidConfiguredAgents = Object.keys(config.agentConfigs).filter((identifier) => !validAgentIdentifiers.has(identifier));
+    if (invalidConfiguredAgents.length > 0) {
+        throw (0, constants_1.createRulerError)(`Invalid agent configured: ${invalidConfiguredAgents.join(', ')}`, `Valid agents are: ${[...validAgentIdentifiers].join(', ')}`);
+    }
     if (config.cliAgents && config.cliAgents.length > 0) {
         const filters = config.cliAgents.map((n) => n.toLowerCase());
         // Check if any of the specified agents don't exist
-        const validAgentIdentifiers = new Set(allAgents.map((agent) => agent.getIdentifier()));
-        const validAgentNames = new Set(allAgents.map((agent) => agent.getName().toLowerCase()));
         const invalidAgents = filters.filter((filter) => !validAgentIdentifiers.has(filter) &&
             ![...validAgentNames].some((name) => name.includes(filter)));
         if (invalidAgents.length > 0) {
@@ -37,8 +41,6 @@ function resolveSelectedAgents(config, allAgents) {
     else if (config.defaultAgents && config.defaultAgents.length > 0) {
         const defaults = config.defaultAgents.map((n) => n.toLowerCase());
         // Check if any of the default agents don't exist
-        const validAgentIdentifiers = new Set(allAgents.map((agent) => agent.getIdentifier()));
-        const validAgentNames = new Set(allAgents.map((agent) => agent.getName().toLowerCase()));
         const invalidAgents = defaults.filter((filter) => !validAgentIdentifiers.has(filter) &&
             ![...validAgentNames].some((name) => name.includes(filter)));
         if (invalidAgents.length > 0) {

package/dist/core/apply-engine.d.ts

@@ -8,6 +8,7 @@ export interface RulerConfiguration {
     config: LoadedConfig;
     concatenatedRules: string;
     rulerMcpJson: Record<string, unknown> | null;
+    projectRoot: string;
 }
 /**
  * Configuration data for a specific .ruler directory in hierarchical mode