rulesync 5.8.0 → 5.9.1

package/dist/index.js

@@ -93,9 +93,6 @@ var Logger = class {
 };
 var logger = new Logger();
 
-// src/cli/commands/generate.ts
-import { intersection } from "es-toolkit";
-
 // src/config/config-resolver.ts
 import { parse as parseJsonc } from "jsonc-parser";
 import { resolve as resolve2 } from "path";
@@ -467,6 +464,10 @@ function getBaseDirsInLightOfGlobal({
   return resolvedBaseDirs;
 }
 
+// src/lib/generate.ts
+import { intersection } from "es-toolkit";
+import { join as join96 } from "path";
+
 // src/constants/rulesync-paths.ts
 import { join as join2 } from "path";
 var RULESYNC_CONFIG_RELATIVE_FILE_PATH = "rulesync.jsonc";
@@ -8916,7 +8917,8 @@ import { join as join74 } from "path";
 import { basename as basename22, join as join73 } from "path";
 import { z as z38 } from "zod/mini";
 var RulesyncRuleFrontmatterSchema = z38.object({
-  root: z38.optional(z38.optional(z38.boolean())),
+  root: z38.optional(z38.boolean()),
+  localRoot: z38.optional(z38.boolean()),
   targets: z38.optional(RulesyncTargetsSchema),
   description: z38.optional(z38.string()),
   globs: z38.optional(z38.array(z38.string())),
@@ -9024,6 +9026,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 ?? [],
@@ -9057,6 +9060,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 ?? [],
@@ -11699,9 +11703,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;
       }
@@ -11712,6 +11718,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);
@@ -11766,6 +11778,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.
    */
@@ -11834,6 +11890,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) {
@@ -11841,6 +11909,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;
@@ -11894,6 +11967,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(
+          join95(this.baseDir, settablePaths.root.relativeDirPath ?? ".", "CLAUDE.local.md")
+        );
+        return localRootFilePaths.map(
+          (filePath) => factory.class.forDeletion({
+            baseDir: this.baseDir,
+            relativeDirPath: settablePaths.root?.relativeDirPath ?? ".",
+            relativeFilePath: basename24(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 [];
@@ -11922,7 +12018,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 [];
@@ -12042,51 +12138,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(join96(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 = intersection(
     config.getTargets(),
     RulesProcessor.getToolTargets({ global: config.getGlobal() })
@@ -12100,7 +12179,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 });
@@ -12109,23 +12188,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 intersection(config.getTargets(), IgnoreProcessor.getToolTargets())) {
     for (const baseDir of config.getBaseDirs()) {
       try {
@@ -12141,30 +12217,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 = intersection(
     config.getTargets(),
     McpProcessor.getToolTargets({ global: config.getGlobal() })
@@ -12184,19 +12254,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 = intersection(
     config.getTargets(),
     CommandsProcessor.getToolTargets({
@@ -12218,19 +12286,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 = intersection(
     config.getTargets(),
     SubagentsProcessor.getToolTargets({
@@ -12252,20 +12318,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 = intersection(
     config.getTargets(),
     SkillsProcessor.getToolTargets({
@@ -12292,15 +12356,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 { 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.");
     }
   }
-  return { totalOutputs: totalSkillOutputs, skills: allSkills };
+  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
-import { join as join96 } from "path";
+import { join as join97 } from "path";
 var RULESYNC_HEADER = "# Generated by Rulesync";
 var LEGACY_RULESYNC_HEADER = "# Generated by rulesync - AI tool configuration files";
 var RULESYNC_IGNORE_ENTRIES = [
@@ -12317,7 +12450,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/",
@@ -12389,6 +12524,7 @@ var RULESYNC_IGNORE_ENTRIES = [
   "**/WARP.md",
   // Others
   "**/modular-mcp.json",
+  ".rulesync/rules/*.local.md",
   "!.rulesync/.aiignore"
 ];
 var isRulesyncHeader = (line) => {
@@ -12441,7 +12577,7 @@ var removeExistingRulesyncEntries = (content) => {
   return result;
 };
 var gitignoreCommand = async () => {
-  const gitignorePath = join96(process.cwd(), ".gitignore");
+  const gitignorePath = join97(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
@@ -12643,7 +12779,7 @@ async function importSkills(config, tool) {
 }
 
 // src/cli/commands/init.ts
-import { join as join97 } from "path";
+import { join as join98 } from "path";
 async function initCommand() {
   logger.info("Initializing rulesync...");
   await ensureDir(RULESYNC_RELATIVE_DIR_PATH);
@@ -12821,14 +12957,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 = join97(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = join98(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 = join97(
+  const mcpFilepath = join98(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
@@ -12838,30 +12974,30 @@ Keep the summary concise and ready to reuse in future tasks.`
   } else {
     logger.info(`Skipped ${mcpFilepath} (already exists)`);
   }
-  const commandFilepath = join97(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = join98(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 = join97(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = join98(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 = join97(skillPaths.relativeDirPath, sampleSkillFile.dirName);
+  const skillDirPath = join98(skillPaths.relativeDirPath, sampleSkillFile.dirName);
   await ensureDir(skillDirPath);
-  const skillFilepath = join97(skillDirPath, SKILL_FILE_NAME);
+  const skillFilepath = join98(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 = join97(
+  const ignoreFilepath = join98(
     ignorePaths.recommended.relativeDirPath,
     ignorePaths.recommended.relativeFilePath
   );
@@ -12880,12 +13016,12 @@ import { FastMCP } from "fastmcp";
 import { z as z51 } from "zod/mini";
 
 // src/mcp/commands.ts
-import { basename as basename25, join as join98 } from "path";
+import { basename as basename25, join as join99 } from "path";
 import { z as z45 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = join98(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = join99(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -12897,7 +13033,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: join98(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join99(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -12923,7 +13059,7 @@ async function getCommand({ relativePathFromCwd }) {
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: join98(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join99(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -12952,7 +13088,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === join98(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === join99(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(`Maximum number of commands (${maxCommandsCount}) reached`);
@@ -12967,11 +13103,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = join98(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = join99(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: join98(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join99(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -12987,11 +13123,11 @@ async function deleteCommand({ relativePathFromCwd }) {
     intendedRootDir: process.cwd()
   });
   const filename = basename25(relativePathFromCwd);
-  const fullPath = join98(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const fullPath = join99(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join98(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join99(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -13016,7 +13152,7 @@ var commandToolSchemas = {
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${join98(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${join99(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -13058,11 +13194,11 @@ var commandTools = {
 };
 
 // src/mcp/ignore.ts
-import { join as join99 } from "path";
+import { join as join100 } from "path";
 import { z as z46 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = join99(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join100(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -13076,7 +13212,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = join99(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join100(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -13097,8 +13233,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const aiignorePath = join99(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
-  const legacyIgnorePath = join99(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const aiignorePath = join100(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = join100(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -13153,7 +13289,7 @@ var ignoreTools = {
 };
 
 // src/mcp/mcp.ts
-import { join as join100 } from "path";
+import { join as join101 } from "path";
 import { z as z47 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
@@ -13163,7 +13299,7 @@ async function getMcpFile() {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    const relativePathFromCwd = join100(
+    const relativePathFromCwd = join101(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -13196,7 +13332,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = join100(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = join101(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -13205,9 +13341,9 @@ async function putMcpFile({ content }) {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    await ensureDir(join100(baseDir, relativeDirPath));
+    await ensureDir(join101(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = join100(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = join101(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -13222,15 +13358,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = join100(
+    const recommendedPath = join101(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = join100(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = join101(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = join100(
+    const relativePathFromCwd = join101(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -13281,12 +13417,12 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-import { basename as basename26, join as join101 } from "path";
+import { basename as basename26, join as join102 } from "path";
 import { z as z48 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = join101(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = join102(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -13299,7 +13435,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: join101(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join102(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -13326,7 +13462,7 @@ async function getRule({ relativePathFromCwd }) {
       validate: true
     });
     return {
-      relativePathFromCwd: join101(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join102(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -13355,7 +13491,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === join101(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === join102(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(`Maximum number of rules (${maxRulesCount}) reached`);
@@ -13368,11 +13504,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = join101(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = join102(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: join101(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join102(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -13388,11 +13524,11 @@ async function deleteRule({ relativePathFromCwd }) {
     intendedRootDir: process.cwd()
   });
   const filename = basename26(relativePathFromCwd);
-  const fullPath = join101(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const fullPath = join102(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join101(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join102(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -13417,7 +13553,7 @@ var ruleToolSchemas = {
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${join101(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${join102(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -13459,7 +13595,7 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-import { basename as basename27, dirname as dirname2, join as join102 } from "path";
+import { basename as basename27, dirname as dirname2, join as join103 } from "path";
 import { z as z49 } from "zod/mini";
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -13483,9 +13619,9 @@ function extractDirName(relativeDirPathFromCwd) {
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = join102(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = join103(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs(join102(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs(join103(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
         const dirName = basename27(dirPath);
@@ -13496,7 +13632,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: join102(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: join103(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -13522,7 +13658,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: join102(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: join103(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -13556,7 +13692,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === join102(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === join103(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(`Maximum number of skills (${maxSkillsCount}) reached`);
@@ -13571,9 +13707,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = join102(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = join103(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = join102(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = join103(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -13581,15 +13717,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      const filePath = join102(skillDirPath, file.name);
-      const fileDir = join102(skillDirPath, dirname2(file.name));
+      const filePath = join103(skillDirPath, file.name);
+      const fileDir = join103(skillDirPath, dirname2(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: join102(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: join103(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -13611,13 +13747,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = join102(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = join103(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: join102(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: join103(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -13650,7 +13786,7 @@ var skillToolSchemas = {
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${join102(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${join103(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -13693,12 +13829,12 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-import { basename as basename28, join as join103 } from "path";
+import { basename as basename28, join as join104 } from "path";
 import { z as z50 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = join103(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = join104(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -13711,7 +13847,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: join103(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join104(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -13740,7 +13876,7 @@ async function getSubagent({ relativePathFromCwd }) {
       validate: true
     });
     return {
-      relativePathFromCwd: join103(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join104(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -13769,7 +13905,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === join103(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === join104(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(`Maximum number of subagents (${maxSubagentsCount}) reached`);
@@ -13782,11 +13918,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = join103(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = join104(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: join103(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join104(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -13802,11 +13938,11 @@ async function deleteSubagent({ relativePathFromCwd }) {
     intendedRootDir: process.cwd()
   });
   const filename = basename28(relativePathFromCwd);
-  const fullPath = join103(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const fullPath = join104(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join103(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join104(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -13834,7 +13970,7 @@ var subagentToolSchemas = {
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${join103(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${join104(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -14085,7 +14221,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "5.8.0";
+var getVersion = () => "5.9.1";
 var main = async () => {
   const program = new Command();
   const version = getVersion();