rulesync 5.8.0 → 5.9.0

package/dist/index.cjs

@@ -116,9 +116,6 @@ var Logger = class {
 };
 var logger = new Logger();
 
-// src/cli/commands/generate.ts
-var import_es_toolkit4 = require("es-toolkit");
-
 // src/config/config-resolver.ts
 var import_jsonc_parser = require("jsonc-parser");
 var import_node_path2 = require("path");
@@ -490,6 +487,10 @@ function getBaseDirsInLightOfGlobal({
   return resolvedBaseDirs;
 }
 
+// src/lib/generate.ts
+var import_es_toolkit4 = require("es-toolkit");
+var import_node_path98 = require("path");
+
 // src/constants/rulesync-paths.ts
 var import_node_path3 = require("path");
 var RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
@@ -8939,7 +8940,8 @@ var import_node_path76 = require("path");
 var import_node_path75 = require("path");
 var import_mini38 = require("zod/mini");
 var RulesyncRuleFrontmatterSchema = import_mini38.z.object({
-  root: import_mini38.z.optional(import_mini38.z.optional(import_mini38.z.boolean())),
+  root: import_mini38.z.optional(import_mini38.z.boolean()),
+  localRoot: import_mini38.z.optional(import_mini38.z.boolean()),
   targets: import_mini38.z.optional(RulesyncTargetsSchema),
   description: import_mini38.z.optional(import_mini38.z.string()),
   globs: import_mini38.z.optional(import_mini38.z.array(import_mini38.z.string())),
@@ -9047,6 +9049,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
     }
     const validatedFrontmatter = {
       root: result.data.root ?? false,
+      localRoot: result.data.localRoot ?? false,
       targets: result.data.targets ?? ["*"],
       description: result.data.description ?? "",
       globs: result.data.globs ?? [],
@@ -9080,6 +9083,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
     }
     const validatedFrontmatter = {
       root: result.data.root ?? false,
+      localRoot: result.data.localRoot ?? false,
       targets: result.data.targets ?? ["*"],
       description: result.data.description ?? "",
       globs: result.data.globs ?? [],
@@ -11722,9 +11726,11 @@ var RulesProcessor = class extends FeatureProcessor {
     const rulesyncRules = rulesyncFiles.filter(
       (file) => file instanceof RulesyncRule
     );
+    const localRootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().localRoot);
+    const nonLocalRootRules = rulesyncRules.filter((rule) => !rule.getFrontmatter().localRoot);
     const factory = this.getFactory(this.toolTarget);
     const { meta } = factory;
-    const toolRules = rulesyncRules.map((rulesyncRule) => {
+    const toolRules = nonLocalRootRules.map((rulesyncRule) => {
       if (!factory.class.isTargetedByRulesyncRule(rulesyncRule)) {
         return null;
       }
@@ -11735,6 +11741,12 @@ var RulesProcessor = class extends FeatureProcessor {
         global: this.global
       });
     }).filter((rule) => rule !== null);
+    if (localRootRules.length > 0 && !this.global) {
+      const localRootRule = localRootRules[0];
+      if (localRootRule && factory.class.isTargetedByRulesyncRule(localRootRule)) {
+        this.handleLocalRootRule(toolRules, localRootRule, factory);
+      }
+    }
     const isSimulated = this.simulateCommands || this.simulateSubagents || this.simulateSkills;
     if (isSimulated && meta.createsSeparateConventionsRule && meta.additionalConventions) {
       const conventionsContent = this.generateAdditionalConventionsSectionFromMeta(meta);
@@ -11789,6 +11801,50 @@ var RulesProcessor = class extends FeatureProcessor {
       };
     });
   }
+  /**
+   * Handle localRoot rule generation based on tool target.
+   * - Claude Code: generates `.claude/CLAUDE.local.md`
+   * - Claude Code Legacy: generates `./CLAUDE.local.md`
+   * - Other tools: appends content to the root file with one blank line separator
+   */
+  handleLocalRootRule(toolRules, localRootRule, _factory) {
+    const localRootBody = localRootRule.getBody();
+    if (this.toolTarget === "claudecode") {
+      const paths = ClaudecodeRule.getSettablePaths({ global: this.global });
+      toolRules.push(
+        new ClaudecodeRule({
+          baseDir: this.baseDir,
+          relativeDirPath: paths.root.relativeDirPath,
+          relativeFilePath: "CLAUDE.local.md",
+          frontmatter: {},
+          body: localRootBody,
+          validate: true,
+          root: true
+          // Treat as root so it doesn't have frontmatter
+        })
+      );
+    } else if (this.toolTarget === "claudecode-legacy") {
+      const paths = ClaudecodeLegacyRule.getSettablePaths({ global: this.global });
+      toolRules.push(
+        new ClaudecodeLegacyRule({
+          baseDir: this.baseDir,
+          relativeDirPath: paths.root.relativeDirPath,
+          relativeFilePath: "CLAUDE.local.md",
+          fileContent: localRootBody,
+          validate: true,
+          root: true
+          // Treat as root so it doesn't have frontmatter
+        })
+      );
+    } else {
+      const rootRule = toolRules.find((rule) => rule.isRoot());
+      if (rootRule) {
+        const currentContent = rootRule.getFileContent();
+        const newContent = currentContent + "\n\n" + localRootBody;
+        rootRule.setFileContent(newContent);
+      }
+    }
+  }
   /**
    * Generate reference section based on meta configuration.
    */
@@ -11857,6 +11913,18 @@ var RulesProcessor = class extends FeatureProcessor {
     if (rootRules.length > 1) {
       throw new Error("Multiple root rulesync rules found");
     }
+    if (rootRules.length === 0 && rulesyncRules.length > 0) {
+      logger.warn(
+        `No root rulesync rule file found. Consider adding 'root: true' to one of your rule files in ${RULESYNC_RULES_RELATIVE_DIR_PATH}.`
+      );
+    }
+    const localRootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().localRoot);
+    if (localRootRules.length > 1) {
+      throw new Error("Multiple localRoot rules found. Only one rule can have localRoot: true");
+    }
+    if (localRootRules.length > 0 && rootRules.length === 0) {
+      throw new Error("localRoot: true requires a root: true rule to exist");
+    }
     if (this.global) {
       const nonRootRules = rulesyncRules.filter((rule) => !rule.getFrontmatter().root);
       if (nonRootRules.length > 0) {
@@ -11864,6 +11932,11 @@ var RulesProcessor = class extends FeatureProcessor {
           `${nonRootRules.length} non-root rulesync rules found, but it's in global mode, so ignoring them`
         );
       }
+      if (localRootRules.length > 0) {
+        logger.warn(
+          `${localRootRules.length} localRoot rules found, but localRoot is not supported in global mode, ignoring them`
+        );
+      }
       return rootRules;
     }
     return rulesyncRules;
@@ -11917,6 +11990,29 @@ var RulesProcessor = class extends FeatureProcessor {
         );
       })();
       logger.debug(`Found ${rootToolRules.length} root tool rule files`);
+      const localRootToolRules = await (async () => {
+        if (!forDeletion) {
+          return [];
+        }
+        if (this.toolTarget !== "claudecode" && this.toolTarget !== "claudecode-legacy") {
+          return [];
+        }
+        if (!settablePaths.root) {
+          return [];
+        }
+        const localRootFilePaths = await findFilesByGlobs(
+          (0, import_node_path97.join)(this.baseDir, settablePaths.root.relativeDirPath ?? ".", "CLAUDE.local.md")
+        );
+        return localRootFilePaths.map(
+          (filePath) => factory.class.forDeletion({
+            baseDir: this.baseDir,
+            relativeDirPath: settablePaths.root?.relativeDirPath ?? ".",
+            relativeFilePath: (0, import_node_path97.basename)(filePath),
+            global: this.global
+          })
+        ).filter((rule) => rule.isDeletable());
+      })();
+      logger.debug(`Found ${localRootToolRules.length} local root tool rule files for deletion`);
       const nonRootToolRules = await (async () => {
         if (!settablePaths.nonRoot) {
           return [];
@@ -11945,7 +12041,7 @@ var RulesProcessor = class extends FeatureProcessor {
         );
       })();
       logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
-      return [...rootToolRules, ...nonRootToolRules];
+      return [...rootToolRules, ...localRootToolRules, ...nonRootToolRules];
     } catch (error) {
       logger.error(`Failed to load tool files: ${formatError(error)}`);
       return [];
@@ -12065,51 +12161,34 @@ ${toonContent}`;
   }
 };
 
-// src/cli/commands/generate.ts
-async function generateCommand(options) {
-  const config = await ConfigResolver.resolve(options);
-  logger.configure({
-    verbose: config.getVerbose(),
-    silent: config.getSilent()
-  });
-  logger.info("Generating files...");
-  if (!await fileExists(RULESYNC_RELATIVE_DIR_PATH)) {
-    logger.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
-    process.exit(1);
-  }
-  logger.info(`Base directories: ${config.getBaseDirs().join(", ")}`);
-  const totalIgnoreOutputs = await generateIgnore(config);
-  const totalMcpOutputs = await generateMcp(config);
-  const totalCommandOutputs = await generateCommands(config);
-  const totalSubagentOutputs = await generateSubagents(config);
-  const skillsResult = await generateSkills(config);
-  const totalRulesOutputs = await generateRules(config, {
+// src/lib/generate.ts
+async function checkRulesyncDirExists(params) {
+  return fileExists((0, import_node_path98.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
+}
+async function generate(params) {
+  const { config } = params;
+  const ignoreCount = await generateIgnoreCore({ config });
+  const mcpCount = await generateMcpCore({ config });
+  const commandsCount = await generateCommandsCore({ config });
+  const subagentsCount = await generateSubagentsCore({ config });
+  const skillsResult = await generateSkillsCore({ config });
+  const rulesCount = await generateRulesCore({ config, skills: skillsResult.skills });
+  return {
+    rulesCount,
+    ignoreCount,
+    mcpCount,
+    commandsCount,
+    subagentsCount,
+    skillsCount: skillsResult.count,
     skills: skillsResult.skills
-  });
-  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs + skillsResult.totalOutputs;
-  if (totalGenerated === 0) {
-    const enabledFeatures = config.getFeatures().join(", ");
-    logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
-    return;
-  }
-  if (totalGenerated > 0) {
-    const parts = [];
-    if (totalRulesOutputs > 0) parts.push(`${totalRulesOutputs} rules`);
-    if (totalIgnoreOutputs > 0) parts.push(`${totalIgnoreOutputs} ignore files`);
-    if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP files`);
-    if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
-    if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
-    if (skillsResult.totalOutputs > 0) parts.push(`${skillsResult.totalOutputs} skills`);
-    logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
-  }
+  };
 }
-async function generateRules(config, options) {
+async function generateRulesCore(params) {
+  const { config, skills } = params;
   if (!config.getFeatures().includes("rules")) {
-    logger.debug("Skipping rule generation (not in --features)");
     return 0;
   }
-  let totalRulesOutputs = 0;
-  logger.info("Generating rule files...");
+  let totalCount = 0;
   const toolTargets = (0, import_es_toolkit4.intersection)(
     config.getTargets(),
     RulesProcessor.getToolTargets({ global: config.getGlobal() })
@@ -12123,7 +12202,7 @@ async function generateRules(config, options) {
         simulateCommands: config.getSimulateCommands(),
         simulateSubagents: config.getSimulateSubagents(),
         simulateSkills: config.getSimulateSkills(),
-        skills: options?.skills
+        skills
       });
       if (config.getDelete()) {
         const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
@@ -12132,23 +12211,20 @@ async function generateRules(config, options) {
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
       const writtenCount = await processor.writeAiFiles(toolFiles);
-      totalRulesOutputs += writtenCount;
-      logger.success(`Generated ${writtenCount} ${toolTarget} rule(s) in ${baseDir}`);
+      totalCount += writtenCount;
     }
   }
-  return totalRulesOutputs;
+  return totalCount;
 }
-async function generateIgnore(config) {
+async function generateIgnoreCore(params) {
+  const { config } = params;
   if (!config.getFeatures().includes("ignore")) {
-    logger.debug("Skipping ignore file generation (not in --features)");
     return 0;
   }
   if (config.getGlobal()) {
-    logger.debug("Skipping ignore file generation (not supported in global mode)");
     return 0;
   }
-  let totalIgnoreOutputs = 0;
-  logger.info("Generating ignore files...");
+  let totalCount = 0;
   for (const toolTarget of (0, import_es_toolkit4.intersection)(config.getTargets(), IgnoreProcessor.getToolTargets())) {
     for (const baseDir of config.getBaseDirs()) {
       try {
@@ -12164,30 +12240,24 @@ async function generateIgnore(config) {
         if (rulesyncFiles.length > 0) {
           const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
           const writtenCount = await processor.writeAiFiles(toolFiles);
-          totalIgnoreOutputs += writtenCount;
-          logger.success(`Generated ${writtenCount} ${toolTarget} ignore file(s) in ${baseDir}`);
+          totalCount += writtenCount;
         }
       } catch (error) {
         logger.warn(
-          `Failed to generate ${toolTarget} ignore files for ${baseDir}:`,
-          error instanceof Error ? error.message : String(error)
+          `Failed to generate ${toolTarget} ignore files for ${baseDir}: ${formatError(error)}`
         );
         continue;
       }
     }
   }
-  return totalIgnoreOutputs;
+  return totalCount;
 }
-async function generateMcp(config) {
+async function generateMcpCore(params) {
+  const { config } = params;
   if (!config.getFeatures().includes("mcp")) {
-    logger.debug("Skipping MCP configuration generation (not in --features)");
     return 0;
   }
-  let totalMcpOutputs = 0;
-  logger.info("Generating MCP files...");
-  if (config.getModularMcp()) {
-    logger.info("\u2139\uFE0F  Modular MCP support is experimental.");
-  }
+  let totalCount = 0;
   const toolTargets = (0, import_es_toolkit4.intersection)(
     config.getTargets(),
     McpProcessor.getToolTargets({ global: config.getGlobal() })
@@ -12207,19 +12277,17 @@ async function generateMcp(config) {
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
       const writtenCount = await processor.writeAiFiles(toolFiles);
-      totalMcpOutputs += writtenCount;
-      logger.success(`Generated ${writtenCount} ${toolTarget} MCP configuration(s) in ${baseDir}`);
+      totalCount += writtenCount;
     }
   }
-  return totalMcpOutputs;
+  return totalCount;
 }
-async function generateCommands(config) {
+async function generateCommandsCore(params) {
+  const { config } = params;
   if (!config.getFeatures().includes("commands")) {
-    logger.debug("Skipping command file generation (not in --features)");
     return 0;
   }
-  let totalCommandOutputs = 0;
-  logger.info("Generating command files...");
+  let totalCount = 0;
   const toolTargets = (0, import_es_toolkit4.intersection)(
     config.getTargets(),
     CommandsProcessor.getToolTargets({
@@ -12241,19 +12309,17 @@ async function generateCommands(config) {
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
       const writtenCount = await processor.writeAiFiles(toolFiles);
-      totalCommandOutputs += writtenCount;
-      logger.success(`Generated ${writtenCount} ${toolTarget} command(s) in ${baseDir}`);
+      totalCount += writtenCount;
     }
   }
-  return totalCommandOutputs;
+  return totalCount;
 }
-async function generateSubagents(config) {
+async function generateSubagentsCore(params) {
+  const { config } = params;
   if (!config.getFeatures().includes("subagents")) {
-    logger.debug("Skipping subagent file generation (not in --features)");
     return 0;
   }
-  let totalSubagentOutputs = 0;
-  logger.info("Generating subagent files...");
+  let totalCount = 0;
   const toolTargets = (0, import_es_toolkit4.intersection)(
     config.getTargets(),
     SubagentsProcessor.getToolTargets({
@@ -12275,20 +12341,18 @@ async function generateSubagents(config) {
       const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
       const writtenCount = await processor.writeAiFiles(toolFiles);
-      totalSubagentOutputs += writtenCount;
-      logger.success(`Generated ${writtenCount} ${toolTarget} subagent(s) in ${baseDir}`);
+      totalCount += writtenCount;
     }
   }
-  return totalSubagentOutputs;
+  return totalCount;
 }
-async function generateSkills(config) {
+async function generateSkillsCore(params) {
+  const { config } = params;
   if (!config.getFeatures().includes("skills")) {
-    logger.debug("Skipping skill generation (not in --features)");
-    return { totalOutputs: 0, skills: [] };
+    return { count: 0, skills: [] };
   }
-  let totalSkillOutputs = 0;
+  let totalCount = 0;
   const allSkills = [];
-  logger.info("Generating skill files...");
   const toolTargets = (0, import_es_toolkit4.intersection)(
     config.getTargets(),
     SkillsProcessor.getToolTargets({
@@ -12315,15 +12379,84 @@ async function generateSkills(config) {
       }
       const toolDirs = await processor.convertRulesyncDirsToToolDirs(rulesyncDirs);
       const writtenCount = await processor.writeAiDirs(toolDirs);
-      totalSkillOutputs += writtenCount;
-      logger.success(`Generated ${writtenCount} ${toolTarget} skill(s) in ${baseDir}`);
+      totalCount += writtenCount;
     }
   }
-  return { totalOutputs: totalSkillOutputs, skills: allSkills };
+  return { count: totalCount, skills: allSkills };
+}
+
+// src/cli/commands/generate.ts
+async function generateCommand(options) {
+  const config = await ConfigResolver.resolve(options);
+  logger.configure({
+    verbose: config.getVerbose(),
+    silent: config.getSilent()
+  });
+  logger.info("Generating files...");
+  if (!await checkRulesyncDirExists({ baseDir: config.getBaseDirs()[0] ?? process.cwd() })) {
+    logger.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
+    process.exit(1);
+  }
+  logger.info(`Base directories: ${config.getBaseDirs().join(", ")}`);
+  const features = config.getFeatures();
+  if (features.includes("ignore")) {
+    logger.info("Generating ignore files...");
+  }
+  if (features.includes("mcp")) {
+    logger.info("Generating MCP files...");
+    if (config.getModularMcp()) {
+      logger.info("\u2139\uFE0F  Modular MCP support is experimental.");
+    }
+  }
+  if (features.includes("commands")) {
+    logger.info("Generating command files...");
+  }
+  if (features.includes("subagents")) {
+    logger.info("Generating subagent files...");
+  }
+  if (features.includes("skills")) {
+    logger.info("Generating skill files...");
+  }
+  if (features.includes("rules")) {
+    logger.info("Generating rule files...");
+  }
+  const result = await generate({ config });
+  if (result.ignoreCount > 0) {
+    logger.success(`Generated ${result.ignoreCount} ignore file(s)`);
+  }
+  if (result.mcpCount > 0) {
+    logger.success(`Generated ${result.mcpCount} MCP configuration(s)`);
+  }
+  if (result.commandsCount > 0) {
+    logger.success(`Generated ${result.commandsCount} command(s)`);
+  }
+  if (result.subagentsCount > 0) {
+    logger.success(`Generated ${result.subagentsCount} subagent(s)`);
+  }
+  if (result.skillsCount > 0) {
+    logger.success(`Generated ${result.skillsCount} skill(s)`);
+  }
+  if (result.rulesCount > 0) {
+    logger.success(`Generated ${result.rulesCount} rule(s)`);
+  }
+  const totalGenerated = result.rulesCount + result.ignoreCount + result.mcpCount + result.commandsCount + result.subagentsCount + result.skillsCount;
+  if (totalGenerated === 0) {
+    const enabledFeatures = features.join(", ");
+    logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
+    return;
+  }
+  const parts = [];
+  if (result.rulesCount > 0) parts.push(`${result.rulesCount} rules`);
+  if (result.ignoreCount > 0) parts.push(`${result.ignoreCount} ignore files`);
+  if (result.mcpCount > 0) parts.push(`${result.mcpCount} MCP files`);
+  if (result.commandsCount > 0) parts.push(`${result.commandsCount} commands`);
+  if (result.subagentsCount > 0) parts.push(`${result.subagentsCount} subagents`);
+  if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
+  logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_path98 = require("path");
+var import_node_path99 = require("path");
 var RULESYNC_HEADER = "# Generated by Rulesync";
 var LEGACY_RULESYNC_HEADER = "# Generated by rulesync - AI tool configuration files";
 var RULESYNC_IGNORE_ENTRIES = [
@@ -12340,7 +12473,9 @@ var RULESYNC_IGNORE_ENTRIES = [
   "**/.augment-guidelines",
   // Claude Code
   "**/CLAUDE.md",
+  "**/CLAUDE.local.md",
   "**/.claude/CLAUDE.md",
+  "**/.claude/CLAUDE.local.md",
   "**/.claude/memories/",
   "**/.claude/rules/",
   "**/.claude/commands/",
@@ -12464,7 +12599,7 @@ var removeExistingRulesyncEntries = (content) => {
   return result;
 };
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path98.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path99.join)(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
@@ -12666,7 +12801,7 @@ async function importSkills(config, tool) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path99 = require("path");
+var import_node_path100 = require("path");
 async function initCommand() {
   logger.info("Initializing rulesync...");
   await ensureDir(RULESYNC_RELATIVE_DIR_PATH);
@@ -12844,14 +12979,14 @@ Keep the summary concise and ready to reuse in future tasks.`
   await ensureDir(subagentPaths.relativeDirPath);
   await ensureDir(skillPaths.relativeDirPath);
   await ensureDir(ignorePaths.recommended.relativeDirPath);
-  const ruleFilepath = (0, import_node_path99.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = (0, import_node_path100.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   if (!await fileExists(ruleFilepath)) {
     await writeFileContent(ruleFilepath, sampleRuleFile.content);
     logger.success(`Created ${ruleFilepath}`);
   } else {
     logger.info(`Skipped ${ruleFilepath} (already exists)`);
   }
-  const mcpFilepath = (0, import_node_path99.join)(
+  const mcpFilepath = (0, import_node_path100.join)(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
@@ -12861,30 +12996,30 @@ Keep the summary concise and ready to reuse in future tasks.`
   } else {
     logger.info(`Skipped ${mcpFilepath} (already exists)`);
   }
-  const commandFilepath = (0, import_node_path99.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = (0, import_node_path100.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
   if (!await fileExists(commandFilepath)) {
     await writeFileContent(commandFilepath, sampleCommandFile.content);
     logger.success(`Created ${commandFilepath}`);
   } else {
     logger.info(`Skipped ${commandFilepath} (already exists)`);
   }
-  const subagentFilepath = (0, import_node_path99.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = (0, import_node_path100.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   if (!await fileExists(subagentFilepath)) {
     await writeFileContent(subagentFilepath, sampleSubagentFile.content);
     logger.success(`Created ${subagentFilepath}`);
   } else {
     logger.info(`Skipped ${subagentFilepath} (already exists)`);
   }
-  const skillDirPath = (0, import_node_path99.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
+  const skillDirPath = (0, import_node_path100.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
   await ensureDir(skillDirPath);
-  const skillFilepath = (0, import_node_path99.join)(skillDirPath, SKILL_FILE_NAME);
+  const skillFilepath = (0, import_node_path100.join)(skillDirPath, SKILL_FILE_NAME);
   if (!await fileExists(skillFilepath)) {
     await writeFileContent(skillFilepath, sampleSkillFile.content);
     logger.success(`Created ${skillFilepath}`);
   } else {
     logger.info(`Skipped ${skillFilepath} (already exists)`);
   }
-  const ignoreFilepath = (0, import_node_path99.join)(
+  const ignoreFilepath = (0, import_node_path100.join)(
     ignorePaths.recommended.relativeDirPath,
     ignorePaths.recommended.relativeFilePath
   );
@@ -12903,12 +13038,12 @@ var import_fastmcp = require("fastmcp");
 var import_mini51 = require("zod/mini");
 
 // src/mcp/commands.ts
-var import_node_path100 = require("path");
+var import_node_path101 = require("path");
 var import_mini45 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = (0, import_node_path100.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = (0, import_node_path101.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -12920,7 +13055,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path100.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path101.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -12940,13 +13075,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path100.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path101.basename)(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: (0, import_node_path100.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path101.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -12965,7 +13100,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path100.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path101.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -12975,7 +13110,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === (0, import_node_path100.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === (0, import_node_path101.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(`Maximum number of commands (${maxCommandsCount}) reached`);
@@ -12990,11 +13125,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = (0, import_node_path100.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = (0, import_node_path101.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path100.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path101.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -13009,12 +13144,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path100.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path100.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path101.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path101.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path100.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path101.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -13039,7 +13174,7 @@ var commandToolSchemas = {
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${(0, import_node_path100.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${(0, import_node_path101.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -13081,11 +13216,11 @@ var commandTools = {
 };
 
 // src/mcp/ignore.ts
-var import_node_path101 = require("path");
+var import_node_path102 = require("path");
 var import_mini46 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path101.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path102.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -13099,7 +13234,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = (0, import_node_path101.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path102.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -13120,8 +13255,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const aiignorePath = (0, import_node_path101.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
-  const legacyIgnorePath = (0, import_node_path101.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const aiignorePath = (0, import_node_path102.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = (0, import_node_path102.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -13176,7 +13311,7 @@ var ignoreTools = {
 };
 
 // src/mcp/mcp.ts
-var import_node_path102 = require("path");
+var import_node_path103 = require("path");
 var import_mini47 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
@@ -13186,7 +13321,7 @@ async function getMcpFile() {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    const relativePathFromCwd = (0, import_node_path102.join)(
+    const relativePathFromCwd = (0, import_node_path103.join)(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -13219,7 +13354,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = (0, import_node_path102.join)(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = (0, import_node_path103.join)(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -13228,9 +13363,9 @@ async function putMcpFile({ content }) {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    await ensureDir((0, import_node_path102.join)(baseDir, relativeDirPath));
+    await ensureDir((0, import_node_path103.join)(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = (0, import_node_path102.join)(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = (0, import_node_path103.join)(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -13245,15 +13380,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = (0, import_node_path102.join)(
+    const recommendedPath = (0, import_node_path103.join)(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = (0, import_node_path102.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = (0, import_node_path103.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = (0, import_node_path102.join)(
+    const relativePathFromCwd = (0, import_node_path103.join)(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -13304,12 +13439,12 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-var import_node_path103 = require("path");
+var import_node_path104 = require("path");
 var import_mini48 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = (0, import_node_path103.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = (0, import_node_path104.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -13322,7 +13457,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path103.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path104.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -13342,14 +13477,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path103.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path104.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path103.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path104.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -13368,7 +13503,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path103.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path104.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -13378,7 +13513,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path103.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path104.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(`Maximum number of rules (${maxRulesCount}) reached`);
@@ -13391,11 +13526,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path103.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = (0, import_node_path104.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path103.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path104.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -13410,12 +13545,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path103.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path103.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path104.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path104.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path103.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path104.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -13440,7 +13575,7 @@ var ruleToolSchemas = {
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${(0, import_node_path103.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${(0, import_node_path104.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -13482,7 +13617,7 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-var import_node_path104 = require("path");
+var import_node_path105 = require("path");
 var import_mini49 = require("zod/mini");
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -13499,19 +13634,19 @@ function mcpSkillFileToAiDirFile(file) {
   };
 }
 function extractDirName(relativeDirPathFromCwd) {
-  const dirName = (0, import_node_path104.basename)(relativeDirPathFromCwd);
+  const dirName = (0, import_node_path105.basename)(relativeDirPathFromCwd);
   if (!dirName) {
     throw new Error(`Invalid path: ${relativeDirPathFromCwd}`);
   }
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = (0, import_node_path104.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = (0, import_node_path105.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs((0, import_node_path104.join)(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs((0, import_node_path105.join)(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
-        const dirName = (0, import_node_path104.basename)(dirPath);
+        const dirName = (0, import_node_path105.basename)(dirPath);
         if (!dirName) return null;
         try {
           const skill = await RulesyncSkill.fromDir({
@@ -13519,7 +13654,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: (0, import_node_path104.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: (0, import_node_path105.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -13545,7 +13680,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: (0, import_node_path104.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path105.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -13579,7 +13714,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path104.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path105.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(`Maximum number of skills (${maxSkillsCount}) reached`);
@@ -13594,9 +13729,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = (0, import_node_path104.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = (0, import_node_path105.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = (0, import_node_path104.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = (0, import_node_path105.join)(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -13604,15 +13739,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      const filePath = (0, import_node_path104.join)(skillDirPath, file.name);
-      const fileDir = (0, import_node_path104.join)(skillDirPath, (0, import_node_path104.dirname)(file.name));
+      const filePath = (0, import_node_path105.join)(skillDirPath, file.name);
+      const fileDir = (0, import_node_path105.join)(skillDirPath, (0, import_node_path105.dirname)(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path104.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path105.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -13634,13 +13769,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = (0, import_node_path104.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = (0, import_node_path105.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path104.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: (0, import_node_path105.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -13673,7 +13808,7 @@ var skillToolSchemas = {
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${(0, import_node_path104.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${(0, import_node_path105.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -13716,12 +13851,12 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-var import_node_path105 = require("path");
+var import_node_path106 = require("path");
 var import_mini50 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = (0, import_node_path105.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = (0, import_node_path106.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -13734,7 +13869,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path105.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path106.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -13756,14 +13891,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path105.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path106.basename)(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path105.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path106.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -13782,7 +13917,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path105.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path106.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -13792,7 +13927,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path105.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path106.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(`Maximum number of subagents (${maxSubagentsCount}) reached`);
@@ -13805,11 +13940,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = (0, import_node_path105.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = (0, import_node_path106.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path105.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path106.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -13824,12 +13959,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path105.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path105.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path106.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path106.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path105.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path106.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -13857,7 +13992,7 @@ var subagentToolSchemas = {
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${(0, import_node_path105.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${(0, import_node_path106.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -14108,7 +14243,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "5.8.0";
+var getVersion = () => "5.9.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();