skiller 0.4.3

package/dist/core/SkillsUtils.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSkillMd = hasSkillMd;
+exports.isGroupingDir = isGroupingDir;
+exports.walkSkillsTree = walkSkillsTree;
+exports.formatValidationWarnings = formatValidationWarnings;
+exports.copySkillsDirectory = copySkillsDirectory;
+exports.copySkillsDirectoryWithTransform = copySkillsDirectoryWithTransform;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const constants_1 = require("../constants");
+/**
+ * Checks if a directory contains a SKILL.md file.
+ */
+async function hasSkillMd(dirPath) {
+    try {
+        const skillMdPath = path.join(dirPath, constants_1.SKILL_MD_FILENAME);
+        await fs.access(skillMdPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Checks if a directory is a grouping directory (contains subdirectories with SKILL.md).
+ */
+async function isGroupingDir(dirPath) {
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const subdirs = entries.filter((e) => e.isDirectory());
+        for (const subdir of subdirs) {
+            const subdirPath = path.join(dirPath, subdir.name);
+            if (await hasSkillMd(subdirPath)) {
+                return true;
+            }
+            // Check recursively for nested grouping
+            if (await isGroupingDir(subdirPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Walks the skills tree and discovers all skills.
+ * Returns skills and any validation warnings.
+ */
+async function walkSkillsTree(root) {
+    const skills = [];
+    const warnings = [];
+    async function walk(currentPath, relativePath) {
+        try {
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const entryPath = path.join(currentPath, entry.name);
+                const entryRelativePath = relativePath
+                    ? path.join(relativePath, entry.name)
+                    : entry.name;
+                const hasSkill = await hasSkillMd(entryPath);
+                const isGrouping = !hasSkill && (await isGroupingDir(entryPath));
+                if (hasSkill) {
+                    // This is a valid skill directory
+                    skills.push({
+                        name: entry.name,
+                        path: entryPath,
+                        hasSkillMd: true,
+                        valid: true,
+                    });
+                }
+                else if (isGrouping) {
+                    // This is a grouping directory, recurse into it
+                    await walk(entryPath, entryRelativePath);
+                }
+                else {
+                    // This is neither a skill nor a grouping directory - warn about it
+                    warnings.push(`Directory '${entryRelativePath}' in .ruler/skills has no SKILL.md and contains no sub-skills. It may be malformed or stray.`);
+                }
+            }
+        }
+        catch (err) {
+            // If we can't read the directory, just return what we have
+            warnings.push(`Failed to read directory ${relativePath || 'root'}: ${err.message}`);
+        }
+    }
+    await walk(root, '');
+    return { skills, warnings };
+}
+/**
+ * Formats validation warnings for display.
+ */
+function formatValidationWarnings(warnings) {
+    if (warnings.length === 0) {
+        return '';
+    }
+    return warnings.map((w) => `  - ${w}`).join('\n');
+}
+/**
+ * Recursively copies a directory and all its contents.
+ */
+async function copyRecursive(src, dest) {
+    const stat = await fs.stat(src);
+    if (stat.isDirectory()) {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            await copyRecursive(srcPath, destPath);
+        }
+    }
+    else {
+        await fs.copyFile(src, dest);
+    }
+}
+/**
+ * Copies the skills directory to the destination, preserving structure.
+ * Creates the destination directory if it doesn't exist.
+ */
+async function copySkillsDirectory(srcDir, destDir) {
+    await fs.mkdir(destDir, { recursive: true });
+    await copyRecursive(srcDir, destDir);
+}
+/**
+ * Recursively copies and transforms skills by expanding @filename references.
+ * Transforms SKILL.md files to replace @filename with actual file content.
+ * This is needed for MCP agents that don't support Claude Code's @filename syntax.
+ */
+async function copyAndTransformSkills(src, dest, projectRoot) {
+    const stat = await fs.stat(src);
+    if (stat.isDirectory()) {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            await copyAndTransformSkills(srcPath, destPath, projectRoot);
+        }
+    }
+    else {
+        // Check if this is a SKILL.md file that needs transformation
+        if (path.basename(src) === constants_1.SKILL_MD_FILENAME) {
+            const content = await fs.readFile(src, 'utf8');
+            const transformed = await expandAtFilenameReferences(content, projectRoot);
+            await fs.writeFile(dest, transformed, 'utf8');
+        }
+        else {
+            // Copy other files as-is
+            await fs.copyFile(src, dest);
+        }
+    }
+}
+/**
+ * Expands @filename references in skill content by replacing them with actual file content.
+ * Strips frontmatter from referenced files to avoid duplication.
+ */
+async function expandAtFilenameReferences(content, projectRoot) {
+    const { parseFrontmatter } = await Promise.resolve().then(() => __importStar(require('./FrontmatterParser')));
+    // Match @filename patterns (e.g., @.claude/rules/foo.mdc or @./relative/path)
+    const atFilenamePattern = /@([^\s]+)/g;
+    let transformed = content;
+    const matches = Array.from(content.matchAll(atFilenamePattern));
+    for (const match of matches) {
+        const fileReference = match[0]; // e.g., "@.claude/rules/foo.mdc"
+        const filePath = match[1]; // e.g., ".claude/rules/foo.mdc"
+        try {
+            // Resolve path relative to project root
+            const absolutePath = path.resolve(projectRoot, filePath);
+            const fileContent = await fs.readFile(absolutePath, 'utf8');
+            // Parse and strip frontmatter from the referenced file
+            // This prevents duplicate frontmatter in the final skill
+            const { body } = parseFrontmatter(fileContent);
+            // Replace the @filename reference with the content (without frontmatter)
+            transformed = transformed.replace(fileReference, body);
+        }
+        catch {
+            // If file can't be read, leave the reference as-is
+            // This allows graceful degradation
+        }
+    }
+    return transformed;
+}
+/**
+ * Copies skills directory with transformation for MCP agents.
+ * Expands @filename references to actual file content since MCP agents
+ * don't support Claude Code's @filename syntax.
+ */
+async function copySkillsDirectoryWithTransform(srcDir, destDir, projectRoot) {
+    await fs.mkdir(destDir, { recursive: true });
+    await copyAndTransformSkills(srcDir, destDir, projectRoot);
+}

package/dist/core/UnifiedConfigLoader.js

@@ -0,0 +1,432 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadUnifiedConfig = loadUnifiedConfig;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const toml_1 = require("@iarna/toml");
+const hash_1 = require("./hash");
+const RuleProcessor_1 = require("./RuleProcessor");
+const FileSystemUtils = __importStar(require("./FileSystemUtils"));
+const FileSystemUtils_1 = require("./FileSystemUtils");
+async function loadUnifiedConfig(options) {
+    // Resolve the effective .ruler directory (local or global), mirroring the main loader behavior
+    const resolvedRulerDir = (await FileSystemUtils.findRulerDir(options.projectRoot, true)) ||
+        path.join(options.projectRoot, '.ruler');
+    const meta = {
+        projectRoot: options.projectRoot,
+        rulerDir: resolvedRulerDir,
+        loadedAt: new Date(),
+        version: '0.0.0-dev',
+    };
+    const diagnostics = [];
+    // Read TOML if available
+    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 (err.code !== 'ENOENT') {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'TOML_READ_ERROR',
+                message: 'Failed to read ruler.toml',
+                file: tomlFile,
+                detail: err.message,
+            });
+        }
+    }
+    let defaultAgents;
+    if (tomlRaw &&
+        typeof tomlRaw === 'object' &&
+        tomlRaw.default_agents &&
+        Array.isArray(tomlRaw.default_agents)) {
+        defaultAgents = tomlRaw.default_agents.map((a) => String(a));
+    }
+    let nested = false;
+    if (tomlRaw &&
+        typeof tomlRaw === 'object' &&
+        typeof tomlRaw.nested === 'boolean') {
+        nested = tomlRaw.nested;
+    }
+    // Parse skills configuration
+    let skillsConfig;
+    if (tomlRaw && typeof tomlRaw === 'object') {
+        const skillsSection = tomlRaw.skills;
+        if (skillsSection && typeof skillsSection === 'object') {
+            const skillsObj = skillsSection;
+            skillsConfig = {};
+            if (typeof skillsObj.enabled === 'boolean') {
+                skillsConfig.enabled = skillsObj.enabled;
+            }
+            if (typeof skillsObj.generate_from_rules === 'boolean') {
+                skillsConfig.generate_from_rules = skillsObj.generate_from_rules;
+            }
+        }
+    }
+    // Parse rules configuration
+    let rulesInclude;
+    let rulesExclude;
+    if (tomlRaw && typeof tomlRaw === 'object') {
+        const rulesSection = tomlRaw.rules;
+        if (rulesSection && typeof rulesSection === 'object') {
+            const rulesObj = rulesSection;
+            if (Array.isArray(rulesObj.include)) {
+                rulesInclude = rulesObj.include.map((p) => String(p));
+            }
+            if (Array.isArray(rulesObj.exclude)) {
+                rulesExclude = rulesObj.exclude.map((p) => String(p));
+            }
+            // Note: merge_strategy is handled in ConfigLoader.ts for single configs
+        }
+    }
+    const toml = {
+        raw: tomlRaw,
+        schemaVersion: 1,
+        agents: {},
+        defaultAgents,
+        nested,
+        skills: skillsConfig,
+    };
+    // Collect rule markdown files
+    let ruleFiles = [];
+    try {
+        const dirEntries = await fs_1.promises.readdir(meta.rulerDir, { withFileTypes: true });
+        let mdFiles = dirEntries
+            .filter((e) => e.isFile() &&
+            (e.name.toLowerCase().endsWith('.md') ||
+                e.name.toLowerCase().endsWith('.mdc')))
+            .map((e) => path.join(meta.rulerDir, e.name));
+        // Apply include/exclude filters
+        if (rulesInclude || rulesExclude) {
+            // Normalize patterns (expand directory patterns to globs)
+            const normalizedInclude = rulesInclude?.map(FileSystemUtils_1.normalizePattern);
+            const normalizedExclude = rulesExclude?.map(FileSystemUtils_1.normalizePattern);
+            mdFiles = mdFiles.filter((file) => {
+                // Get relative path from rulerDir for pattern matching
+                const relativePath = path.relative(meta.rulerDir, file);
+                // Normalize to forward slashes for consistent pattern matching
+                const normalizedPath = relativePath.replace(/\\/g, '/');
+                // Check exclude patterns first (they take precedence)
+                if (normalizedExclude) {
+                    for (const pattern of normalizedExclude) {
+                        if ((0, FileSystemUtils_1.matchesPattern)(normalizedPath, pattern)) {
+                            return false; // Exclude this file
+                        }
+                    }
+                }
+                // If include patterns are specified, file must match at least one
+                if (normalizedInclude && normalizedInclude.length > 0) {
+                    for (const pattern of normalizedInclude) {
+                        if ((0, FileSystemUtils_1.matchesPattern)(normalizedPath, pattern)) {
+                            return true; // Include this file
+                        }
+                    }
+                    return false; // No include pattern matched
+                }
+                // No include patterns specified, file passed exclude check
+                return true;
+            });
+        }
+        // Sort lexicographically then ensure AGENTS.md first
+        mdFiles.sort((a, b) => a.localeCompare(b));
+        mdFiles.sort((a, b) => {
+            const aIs = /agents\.md$/i.test(a);
+            const bIs = /agents\.md$/i.test(b);
+            if (aIs && !bIs)
+                return -1;
+            if (bIs && !aIs)
+                return 1;
+            return 0;
+        });
+        let order = 0;
+        ruleFiles = await Promise.all(mdFiles.map(async (file) => {
+            const content = await fs_1.promises.readFile(file, 'utf8');
+            const stat = await fs_1.promises.stat(file);
+            return {
+                path: file,
+                relativePath: path.basename(file),
+                content,
+                contentHash: (0, hash_1.sha256)(content),
+                mtimeMs: stat.mtimeMs,
+                size: stat.size,
+                order: order++,
+                primary: /agents\.md$/i.test(file),
+            };
+        }));
+    }
+    catch (err) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'RULES_READ_ERROR',
+            message: 'Failed reading rule files',
+            file: meta.rulerDir,
+            detail: err.message,
+        });
+    }
+    const concatenated = (0, RuleProcessor_1.concatenateRules)(ruleFiles.map((f) => ({ path: f.path, content: f.content })), path.dirname(meta.rulerDir));
+    const rules = {
+        files: ruleFiles,
+        concatenated,
+        concatenatedHash: (0, hash_1.sha256)(concatenated),
+    };
+    // Parse TOML MCP servers
+    const tomlMcpServers = {};
+    if (tomlRaw && typeof tomlRaw === 'object') {
+        const tomlObj = tomlRaw;
+        if (tomlObj.mcp_servers && typeof tomlObj.mcp_servers === 'object') {
+            const mcpServersRaw = tomlObj.mcp_servers;
+            for (const [name, def] of Object.entries(mcpServersRaw)) {
+                if (!def || typeof def !== 'object')
+                    continue;
+                const serverDef = def;
+                const server = {};
+                // Parse command and args
+                if (typeof serverDef.command === 'string') {
+                    server.command = serverDef.command;
+                }
+                if (Array.isArray(serverDef.args)) {
+                    server.args = serverDef.args.map(String);
+                }
+                // Parse env
+                if (serverDef.env && typeof serverDef.env === 'object') {
+                    server.env = Object.fromEntries(Object.entries(serverDef.env).filter(([, v]) => typeof v === 'string'));
+                }
+                // Parse URL and headers
+                if (typeof serverDef.url === 'string') {
+                    server.url = serverDef.url;
+                }
+                if (serverDef.headers && typeof serverDef.headers === 'object') {
+                    server.headers = Object.fromEntries(Object.entries(serverDef.headers).filter(([, v]) => typeof v === 'string'));
+                }
+                // Validate server configuration
+                const hasCommand = !!server.command;
+                const hasUrl = !!server.url;
+                if (!hasCommand && !hasUrl) {
+                    diagnostics.push({
+                        severity: 'warning',
+                        code: 'MCP_TOML_INVALID_SERVER',
+                        message: `MCP server '${name}' must have at least one of command or url`,
+                        file: tomlFile,
+                    });
+                    continue;
+                }
+                if (hasCommand && hasUrl) {
+                    diagnostics.push({
+                        severity: 'warning',
+                        code: 'MCP_TOML_FIELD_CONFLICT',
+                        message: `MCP server '${name}' has both command and url - using url (remote)`,
+                        file: tomlFile,
+                    });
+                }
+                if (hasCommand && server.headers) {
+                    diagnostics.push({
+                        severity: 'warning',
+                        code: 'MCP_TOML_FIELD_CONFLICT',
+                        message: `MCP server '${name}' has headers with command (should be used with url only)`,
+                        file: tomlFile,
+                    });
+                }
+                if (hasUrl && server.env) {
+                    diagnostics.push({
+                        severity: 'warning',
+                        code: 'MCP_TOML_FIELD_CONFLICT',
+                        message: `MCP server '${name}' has env with url (should be used with command only)`,
+                        file: tomlFile,
+                    });
+                }
+                // Derive type - remote takes precedence if both are present
+                if (server.url) {
+                    server.type = 'remote';
+                }
+                else if (server.command) {
+                    server.type = 'stdio';
+                }
+                tomlMcpServers[name] = server;
+            }
+        }
+    }
+    // Store TOML MCP servers in toml config
+    toml.mcpServers = tomlMcpServers;
+    // MCP normalization - merge JSON and TOML
+    let mcp = null;
+    const mcpFile = path.join(meta.rulerDir, 'mcp.json');
+    const jsonMcpServers = {};
+    let mcpJsonExists = false;
+    // Pre-flight existence check so users see warning even if JSON invalid
+    try {
+        await fs_1.promises.access(mcpFile);
+        mcpJsonExists = true;
+        // Warning is handled by apply-engine to avoid duplication
+    }
+    catch {
+        // file not present
+    }
+    // Add deprecation warning if mcp.json exists (regardless of validity)
+    if (mcpJsonExists) {
+        meta.mcpFile = mcpFile;
+        diagnostics.push({
+            severity: 'warning',
+            code: 'MCP_JSON_DEPRECATED',
+            message: 'mcp.json detected: please migrate MCP servers to ruler.toml [mcp_servers.*] sections',
+            file: mcpFile,
+        });
+    }
+    try {
+        if (mcpJsonExists) {
+            const raw = await fs_1.promises.readFile(mcpFile, 'utf8');
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (e) {
+                // Lenient fallback: strip comments and trailing commas then retry
+                const stripped = raw
+                    // strip /* */ comments
+                    .replace(/\/\*[\s\S]*?\*\//g, '')
+                    // strip // comments
+                    .replace(/(^|\s+)\/\/.*$/gm, '$1')
+                    // remove trailing commas before } or ]
+                    .replace(/,\s*([}\]])/g, '$1');
+                try {
+                    parsed = JSON.parse(stripped);
+                }
+                catch {
+                    throw e; // rethrow original error for diagnostics
+                }
+            }
+            const parsedObj = parsed;
+            const serversRaw = parsedObj.mcpServers ||
+                parsedObj.servers ||
+                {};
+            if (serversRaw && typeof serversRaw === 'object') {
+                for (const [name, def] of Object.entries(serversRaw)) {
+                    if (!def || typeof def !== 'object')
+                        continue;
+                    const server = {};
+                    if (typeof def.command === 'string')
+                        server.command = def.command;
+                    if (Array.isArray(def.command))
+                        server.command = def.command[0];
+                    if (Array.isArray(def.args))
+                        server.args = def.args.map(String);
+                    if (def.env && typeof def.env === 'object') {
+                        server.env = Object.fromEntries(Object.entries(def.env).filter(([, v]) => typeof v === 'string'));
+                    }
+                    if (typeof def.url === 'string')
+                        server.url = def.url;
+                    if (def.headers && typeof def.headers === 'object') {
+                        server.headers = Object.fromEntries(Object.entries(def.headers).filter(([, v]) => typeof v === 'string'));
+                    }
+                    // Derive type
+                    if (server.url)
+                        server.type = 'remote';
+                    else if (server.command)
+                        server.type = 'stdio';
+                    jsonMcpServers[name] = server;
+                }
+            }
+        }
+    }
+    catch (err) {
+        if (mcpJsonExists) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'MCP_READ_ERROR',
+                message: 'Failed to read mcp.json',
+                file: mcpFile,
+                detail: err.message,
+            });
+        }
+    }
+    // Merge servers: start with JSON, overlay TOML (TOML wins per server name)
+    const mergedServers = { ...jsonMcpServers, ...tomlMcpServers };
+    // Create MCP bundle if we have any servers
+    if (Object.keys(mergedServers).length > 0 || mcpJsonExists) {
+        mcp = {
+            servers: mergedServers,
+            raw: mcpJsonExists ? { mcpServers: jsonMcpServers } : {},
+            hash: (0, hash_1.sha256)((0, hash_1.stableJson)(mergedServers)),
+        };
+    }
+    const config = {
+        meta,
+        toml,
+        rules,
+        mcp,
+        agents: {},
+        diagnostics,
+        hash: '', // placeholder, recompute after agents
+    };
+    // Agent resolution (basic): enabled set is CLI override or default_agents
+    const cliAgents = options.cliAgents && options.cliAgents.length > 0
+        ? options.cliAgents
+        : undefined;
+    const enabledList = cliAgents ?? toml.defaultAgents ?? [];
+    for (const name of enabledList) {
+        config.agents[name] = {
+            identifier: name,
+            enabled: true,
+            output: {},
+            mcp: { enabled: false, strategy: 'merge' },
+        };
+    }
+    // If CLI provided, mark defaults not included as disabled (optional design choice)
+    if (cliAgents) {
+        for (const name of toml.defaultAgents ?? []) {
+            if (!config.agents[name]) {
+                config.agents[name] = {
+                    identifier: name,
+                    enabled: false,
+                    output: {},
+                    mcp: { enabled: false, strategy: 'merge' },
+                };
+            }
+        }
+    }
+    // Recompute hash including agents list
+    config.hash = (0, hash_1.sha256)((0, hash_1.stableJson)({
+        toml: toml.defaultAgents,
+        rules: rules.concatenatedHash,
+        mcp: mcp ? mcp.hash : null,
+        agents: Object.entries(config.agents).map(([k, v]) => [k, v.enabled]),
+    }));
+    return config;
+}

package/dist/core/UnifiedConfigTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });