rulesync 7.30.0 → 8.0.0

package/dist/cli/index.cjs

@@ -6501,7 +6501,8 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
       relativeDirPath: paths.relativeDirPath,
       relativeFilePath: paths.relativeFilePath,
       fileContent: JSON.stringify(newJson, null, 2),
-      validate
+      validate,
+      global
     });
   }
   static async fromRulesyncMcp({
@@ -6522,7 +6523,8 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
       relativeDirPath: paths.relativeDirPath,
       relativeFilePath: paths.relativeFilePath,
       fileContent: JSON.stringify(mcpJson, null, 2),
-      validate
+      validate,
+      global
     });
   }
   toRulesyncMcp() {
@@ -17931,14 +17933,21 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
     rulesyncRule,
     validate = true
   }) {
-    return new _WindsurfRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
+    const toolRuleParams = this.buildToolRuleParamsDefault({
+      baseDir,
+      rulesyncRule,
+      validate,
+      nonRootPath: this.getSettablePaths().nonRoot
+    });
+    const windsurfFrontmatter = this.buildWindsurfFrontmatter({
+      relativeFilePath: rulesyncRule.getRelativeFilePath(),
+      description: rulesyncRule.getFrontmatter().description,
+      globs: rulesyncRule.getFrontmatter().globs
+    });
+    return new _WindsurfRule({
+      ...toolRuleParams,
+      fileContent: stringifyFrontmatter(rulesyncRule.getBody(), windsurfFrontmatter)
+    });
   }
   toRulesyncRule() {
     return this.toRulesyncRuleDefault();
@@ -17965,6 +17974,18 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
       toolTarget: "windsurf"
     });
   }
+  static buildWindsurfFrontmatter({
+    relativeFilePath,
+    description,
+    globs
+  }) {
+    const hasSpecificGlobs = Boolean(globs && globs.length > 0 && !globs.includes("**/*"));
+    return {
+      title: description ?? relativeFilePath.replace(/\.md$/, ""),
+      trigger: hasSpecificGlobs ? "glob" : "always_on",
+      ...hasSpecificGlobs && { globs }
+    };
+  }
 };
 
 // src/features/rules/rules-processor.ts
@@ -17997,6 +18018,28 @@ var rulesProcessorToolTargets = [
 ];
 var RulesProcessorToolTargetSchema = import_mini65.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path131.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
+var RulesFeatureOptionsSchema = import_mini65.z.looseObject({
+  ruleDiscoveryMode: import_mini65.z.optional(import_mini65.z.enum(["none", "explicit"]))
+});
+var resolveRuleDiscoveryMode = ({
+  defaultMode,
+  options
+}) => {
+  if (defaultMode === "claudecode-legacy") {
+    return defaultMode;
+  }
+  if (!options) return defaultMode;
+  const parsed = RulesFeatureOptionsSchema.safeParse(options);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid options for rules feature: ${parsed.error.message}. \`ruleDiscoveryMode\` must be either "none" or "explicit".`
+    );
+  }
+  if (!parsed.data.ruleDiscoveryMode) {
+    return defaultMode;
+  }
+  return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
+};
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -18311,6 +18354,7 @@ var RulesProcessor = class extends FeatureProcessor {
   global;
   getFactory;
   skills;
+  featureOptions;
   constructor({
     baseDir = process.cwd(),
     toolTarget,
@@ -18320,6 +18364,7 @@ var RulesProcessor = class extends FeatureProcessor {
     global = false,
     getFactory = defaultGetFactory6,
     skills,
+    featureOptions,
     dryRun = false,
     logger: logger5
   }) {
@@ -18337,6 +18382,7 @@ var RulesProcessor = class extends FeatureProcessor {
     this.simulateSkills = simulateSkills;
     this.getFactory = getFactory;
     this.skills = skills;
+    this.featureOptions = featureOptions;
   }
   async convertRulesyncFilesToToolFiles(rulesyncFiles) {
     const rulesyncRules = rulesyncFiles.filter(
@@ -18494,7 +18540,11 @@ var RulesProcessor = class extends FeatureProcessor {
    * Generate reference section based on meta configuration.
    */
   generateReferenceSectionFromMeta(meta, toolRules) {
-    switch (meta.ruleDiscoveryMode) {
+    const mode = resolveRuleDiscoveryMode({
+      defaultMode: meta.ruleDiscoveryMode,
+      options: this.featureOptions
+    });
+    switch (mode) {
       case "toon":
         return this.generateToonReferencesSection(toolRules);
       case "claudecode-legacy":
@@ -20243,11 +20293,11 @@ function getBaseDirsInLightOfGlobal({
 }
 
 // src/lib/generate.ts
-var import_node_path138 = require("path");
+var import_node_path140 = require("path");
 var import_es_toolkit5 = require("es-toolkit");
 
 // src/features/permissions/permissions-processor.ts
-var import_mini72 = require("zod/mini");
+var import_mini73 = require("zod/mini");
 
 // src/features/permissions/claudecode-permissions.ts
 var import_node_path136 = require("path");
@@ -20572,16 +20622,382 @@ function convertClaudeToRulesyncPermissions(params) {
   return { permission };
 }
 
-// src/features/permissions/opencode-permissions.ts
+// src/features/permissions/codexcli-permissions.ts
 var import_node_path137 = require("path");
-var import_jsonc_parser5 = require("jsonc-parser");
+var smolToml5 = __toESM(require("smol-toml"), 1);
+var RULESYNC_PROFILE_NAME = "rulesync";
+var CodexcliPermissions = class _CodexcliPermissions extends ToolPermissions {
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: ".codex",
+      relativeFilePath: "config.toml"
+    };
+  }
+  isDeletable() {
+    return false;
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path137.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? smolToml5.stringify({});
+    return new _CodexcliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    validate = true,
+    logger: logger5,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path137.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const existingContent = await readFileContentOrNull(filePath) ?? smolToml5.stringify({});
+    const parsed = toMutableTable(smolToml5.parse(existingContent));
+    const profile = convertRulesyncToCodexProfile({
+      config: rulesyncPermissions.getJson(),
+      logger: logger5
+    });
+    const permissionsTable = toMutableTable(parsed.permissions);
+    permissionsTable[RULESYNC_PROFILE_NAME] = profile;
+    parsed.permissions = permissionsTable;
+    parsed.default_permissions = RULESYNC_PROFILE_NAME;
+    return new _CodexcliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: smolToml5.stringify(parsed),
+      validate
+    });
+  }
+  toRulesyncPermissions() {
+    let parsed;
+    try {
+      parsed = smolToml5.parse(this.getFileContent());
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Codex CLI permissions content in ${(0, import_node_path137.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const table = toMutableTable(parsed);
+    const defaultProfile = typeof table.default_permissions === "string" ? table.default_permissions : void 0;
+    const permissionsTable = toMutableTable(table.permissions);
+    const profile = toCodexProfile(permissionsTable[defaultProfile ?? RULESYNC_PROFILE_NAME]) ?? toCodexProfile(permissionsTable[RULESYNC_PROFILE_NAME]);
+    const config = convertCodexProfileToRulesync(profile);
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify(config, null, 2)
+    });
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _CodexcliPermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: smolToml5.stringify({}),
+      validate: false
+    });
+  }
+};
+function convertRulesyncToCodexProfile({
+  config,
+  logger: logger5
+}) {
+  const filesystem = {};
+  const domains = {};
+  for (const [toolName, rules] of Object.entries(config.permission)) {
+    if (toolName === "read") {
+      for (const [pattern, action] of Object.entries(rules)) {
+        filesystem[pattern] = mapReadAction(action);
+      }
+      continue;
+    }
+    if (toolName === "edit" || toolName === "write") {
+      for (const [pattern, action] of Object.entries(rules)) {
+        filesystem[pattern] = mapWriteAction(action);
+      }
+      continue;
+    }
+    if (toolName === "webfetch") {
+      for (const [pattern, action] of Object.entries(rules)) {
+        if (action === "ask") {
+          logger5?.warn(
+            `Codex CLI does not support "ask" for network domain permissions. Skipping webfetch rule: ${pattern}`
+          );
+          continue;
+        }
+        domains[pattern] = action;
+      }
+      continue;
+    }
+    logger5?.warn(
+      `Codex CLI permissions support only read/edit/write/webfetch categories. Skipping: ${toolName}`
+    );
+  }
+  return {
+    ...Object.keys(filesystem).length > 0 ? { filesystem } : {},
+    ...Object.keys(domains).length > 0 ? { network: { domains } } : {}
+  };
+}
+function convertCodexProfileToRulesync(profile) {
+  const permission = {};
+  if (profile?.filesystem) {
+    permission.read = {};
+    permission.edit = {};
+    for (const [pattern, access] of Object.entries(profile.filesystem)) {
+      if (access === "none") {
+        permission.read[pattern] = "deny";
+        permission.edit[pattern] = "deny";
+      } else if (access === "read") {
+        permission.read[pattern] = "allow";
+      } else {
+        permission.edit[pattern] = "allow";
+      }
+    }
+  }
+  if (profile?.network?.domains) {
+    permission.webfetch = {};
+    for (const [domain, value] of Object.entries(profile.network.domains)) {
+      permission.webfetch[domain] = value;
+    }
+  }
+  return { permission };
+}
+function toCodexProfile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const table = toMutableTable(value);
+  const filesystem = toFilesystemRecord(table.filesystem);
+  const networkRaw = toMutableTable(table.network);
+  const domains = toDomainRecord(networkRaw.domains);
+  return {
+    ...filesystem ? { filesystem } : {},
+    ...domains ? { network: { domains } } : {}
+  };
+}
+function toMutableTable(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+function toFilesystemRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw !== "string") continue;
+    if (raw === "read" || raw === "write" || raw === "none") {
+      result[key] = raw;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function toDomainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const result = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (raw === "allow" || raw === "deny") {
+      result[key] = raw;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function mapReadAction(action) {
+  return action === "allow" ? "read" : "none";
+}
+function mapWriteAction(action) {
+  return action === "allow" ? "write" : "none";
+}
+
+// src/features/permissions/geminicli-permissions.ts
+var import_node_path138 = require("path");
 var import_mini71 = require("zod/mini");
-var OpencodePermissionSchema = import_mini71.z.union([
-  import_mini71.z.enum(["allow", "ask", "deny"]),
-  import_mini71.z.record(import_mini71.z.string(), import_mini71.z.enum(["allow", "ask", "deny"]))
+var GeminiCliSettingsSchema = import_mini71.z.looseObject({
+  tools: import_mini71.z.optional(
+    import_mini71.z.looseObject({
+      allowed: import_mini71.z.optional(import_mini71.z.array(import_mini71.z.string())),
+      exclude: import_mini71.z.optional(import_mini71.z.array(import_mini71.z.string()))
+    })
+  )
+});
+var RULESYNC_TO_GEMINICLI_TOOL_NAME = {
+  bash: "run_shell_command",
+  read: "read_file",
+  edit: "replace",
+  write: "write_file",
+  webfetch: "web_fetch"
+};
+var GeminicliPermissions = class _GeminicliPermissions extends ToolPermissions {
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: ".gemini",
+      relativeFilePath: "settings.json"
+    };
+  }
+  isDeletable() {
+    return false;
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path138.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    return new _GeminicliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    validate = true,
+    logger: logger5,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = (0, import_node_path138.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    const settingsResult = GeminiCliSettingsSchema.safeParse(JSON.parse(existingContent));
+    if (!settingsResult.success) {
+      throw new Error(
+        `Failed to parse existing Gemini CLI settings at ${filePath}: ${formatError(settingsResult.error)}`
+      );
+    }
+    const { allowed, exclude } = convertRulesyncToGeminicliTools({
+      config: rulesyncPermissions.getJson(),
+      logger: logger5
+    });
+    const merged = {
+      ...settingsResult.data,
+      tools: {
+        ...settingsResult.data.tools,
+        ...allowed.length > 0 ? { allowed } : {},
+        ...exclude.length > 0 ? { exclude } : {}
+      }
+    };
+    return new _GeminicliPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(merged, null, 2),
+      validate
+    });
+  }
+  toRulesyncPermissions() {
+    let settings;
+    try {
+      const parsed = JSON.parse(this.getFileContent());
+      settings = GeminiCliSettingsSchema.parse(parsed);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Gemini CLI permissions content in ${(0, import_node_path138.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const permission = {};
+    for (const toolEntry of settings.tools?.allowed ?? []) {
+      const mapped = parseGeminicliToolEntry({ entry: toolEntry });
+      const rules = permission[mapped.category] ??= {};
+      rules[mapped.pattern] = "allow";
+    }
+    for (const toolEntry of settings.tools?.exclude ?? []) {
+      const mapped = parseGeminicliToolEntry({ entry: toolEntry });
+      const rules = permission[mapped.category] ??= {};
+      rules[mapped.pattern] = "deny";
+    }
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify({ permission }, null, 2)
+    });
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _GeminicliPermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify({}, null, 2),
+      validate: false
+    });
+  }
+};
+function convertRulesyncToGeminicliTools({
+  config,
+  logger: logger5
+}) {
+  const allowed = [];
+  const exclude = [];
+  for (const [toolName, rules] of Object.entries(config.permission)) {
+    const mappedToolName = RULESYNC_TO_GEMINICLI_TOOL_NAME[toolName] ?? toolName;
+    if (!RULESYNC_TO_GEMINICLI_TOOL_NAME[toolName]) {
+      logger5?.warn(`Gemini CLI permissions use direct tool names. Mapping as-is: ${toolName}`);
+    }
+    for (const [pattern, action] of Object.entries(rules)) {
+      if (action === "ask") {
+        logger5?.warn(
+          `Gemini CLI does not support explicit "ask" rules in settings. Skipping ${toolName}:${pattern}`
+        );
+        continue;
+      }
+      const geminiEntry = pattern === "*" ? mappedToolName : `${mappedToolName}(${pattern})`;
+      if (action === "allow") {
+        allowed.push(geminiEntry);
+      } else {
+        exclude.push(geminiEntry);
+      }
+    }
+  }
+  return { allowed, exclude };
+}
+function parseGeminicliToolEntry({ entry }) {
+  const match = /^([^()]+?)(?:\((.*)\))?$/.exec(entry);
+  if (!match) return { category: entry, pattern: "*" };
+  const rawToolName = match[1]?.trim() ?? entry;
+  const mappedCategory = Object.entries(RULESYNC_TO_GEMINICLI_TOOL_NAME).find(
+    ([, value]) => value === rawToolName
+  )?.[0];
+  return {
+    category: mappedCategory ?? rawToolName,
+    pattern: (match[2] ?? "*").trim()
+  };
+}
+
+// src/features/permissions/opencode-permissions.ts
+var import_node_path139 = require("path");
+var import_jsonc_parser5 = require("jsonc-parser");
+var import_mini72 = require("zod/mini");
+var OpencodePermissionSchema = import_mini72.z.union([
+  import_mini72.z.enum(["allow", "ask", "deny"]),
+  import_mini72.z.record(import_mini72.z.string(), import_mini72.z.enum(["allow", "ask", "deny"]))
 ]);
-var OpencodePermissionsConfigSchema = import_mini71.z.looseObject({
-  permission: import_mini71.z.optional(import_mini71.z.record(import_mini71.z.string(), OpencodePermissionSchema))
+var OpencodePermissionsConfigSchema = import_mini72.z.looseObject({
+  permission: import_mini72.z.optional(import_mini72.z.record(import_mini72.z.string(), OpencodePermissionSchema))
 });
 var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   json;
@@ -20598,7 +21014,7 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   static getSettablePaths({
     global = false
   } = {}) {
-    return global ? { relativeDirPath: (0, import_node_path137.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
+    return global ? { relativeDirPath: (0, import_node_path139.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
   }
   static async fromFile({
     baseDir = process.cwd(),
@@ -20606,9 +21022,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    const jsonDir = (0, import_node_path137.join)(baseDir, basePaths.relativeDirPath);
-    const jsoncPath = (0, import_node_path137.join)(jsonDir, "opencode.jsonc");
-    const jsonPath = (0, import_node_path137.join)(jsonDir, "opencode.json");
+    const jsonDir = (0, import_node_path139.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path139.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path139.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -20633,9 +21049,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    const jsonDir = (0, import_node_path137.join)(baseDir, basePaths.relativeDirPath);
-    const jsoncPath = (0, import_node_path137.join)(jsonDir, "opencode.jsonc");
-    const jsonPath = (0, import_node_path137.join)(jsonDir, "opencode.json");
+    const jsonDir = (0, import_node_path139.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path139.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path139.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -20705,8 +21121,13 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
 };
 
 // src/features/permissions/permissions-processor.ts
-var permissionsProcessorToolTargetTuple = ["claudecode", "opencode"];
-var PermissionsProcessorToolTargetSchema = import_mini72.z.enum(permissionsProcessorToolTargetTuple);
+var permissionsProcessorToolTargetTuple = [
+  "claudecode",
+  "codexcli",
+  "geminicli",
+  "opencode"
+];
+var PermissionsProcessorToolTargetSchema = import_mini73.z.enum(permissionsProcessorToolTargetTuple);
 var toolPermissionsFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -20719,6 +21140,28 @@ var toolPermissionsFactories = /* @__PURE__ */ new Map([
       }
     }
   ],
+  [
+    "codexcli",
+    {
+      class: CodexcliPermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: true,
+        supportsImport: true
+      }
+    }
+  ],
+  [
+    "geminicli",
+    {
+      class: GeminicliPermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: true,
+        supportsImport: true
+      }
+    }
+  ],
   [
     "opencode",
     {
@@ -20901,7 +21344,7 @@ function warnUnsupportedTargets(params) {
   }
 }
 async function checkRulesyncDirExists(params) {
-  return fileExists((0, import_node_path138.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
+  return fileExists((0, import_node_path140.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
 }
 async function generate(params) {
   const { config, logger: logger5 } = params;
@@ -20956,6 +21399,7 @@ async function generateRulesCore(params) {
         simulateSubagents: config.getSimulateSubagents(),
         simulateSkills: config.getSimulateSkills(),
         skills,
+        featureOptions: config.getFeatureOptions(toolTarget, "rules"),
         dryRun: config.isPreviewMode(),
         logger: logger5
       });
@@ -21370,7 +21814,7 @@ async function generateCommand(logger5, options) {
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_path139 = require("path");
+var import_node_path141 = require("path");
 
 // src/cli/commands/gitignore-entries.ts
 var normalizeGitignoreEntryTargets = (target) => {
@@ -21708,7 +22152,7 @@ var removeExistingRulesyncEntries = (content) => {
   return result;
 };
 var gitignoreCommand = async (logger5, options) => {
-  const gitignorePath = (0, import_node_path139.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path141.join)(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
@@ -22069,7 +22513,7 @@ async function importCommand(logger5, options) {
 }
 
 // src/lib/init.ts
-var import_node_path140 = require("path");
+var import_node_path142 = require("path");
 async function init() {
   const sampleFiles = await createSampleFiles();
   const configFile = await createConfigFile();
@@ -22261,27 +22705,27 @@ 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_path140.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = (0, import_node_path142.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   results.push(await writeIfNotExists(ruleFilepath, sampleRuleFile.content));
-  const mcpFilepath = (0, import_node_path140.join)(
+  const mcpFilepath = (0, import_node_path142.join)(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(mcpFilepath, sampleMcpFile.content));
-  const commandFilepath = (0, import_node_path140.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = (0, import_node_path142.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
   results.push(await writeIfNotExists(commandFilepath, sampleCommandFile.content));
-  const subagentFilepath = (0, import_node_path140.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = (0, import_node_path142.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   results.push(await writeIfNotExists(subagentFilepath, sampleSubagentFile.content));
-  const skillDirPath = (0, import_node_path140.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
+  const skillDirPath = (0, import_node_path142.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
   await ensureDir(skillDirPath);
-  const skillFilepath = (0, import_node_path140.join)(skillDirPath, SKILL_FILE_NAME);
+  const skillFilepath = (0, import_node_path142.join)(skillDirPath, SKILL_FILE_NAME);
   results.push(await writeIfNotExists(skillFilepath, sampleSkillFile.content));
-  const ignoreFilepath = (0, import_node_path140.join)(
+  const ignoreFilepath = (0, import_node_path142.join)(
     ignorePaths.recommended.relativeDirPath,
     ignorePaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(ignoreFilepath, sampleIgnoreFile.content));
-  const hooksFilepath = (0, import_node_path140.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
+  const hooksFilepath = (0, import_node_path142.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
   results.push(await writeIfNotExists(hooksFilepath, sampleHooksFile.content));
   return results;
 }
@@ -22329,12 +22773,12 @@ async function initCommand(logger5) {
 }
 
 // src/lib/sources.ts
-var import_node_path143 = require("path");
+var import_node_path145 = require("path");
 var import_promise2 = require("es-toolkit/promise");
 
 // src/lib/git-client.ts
 var import_node_child_process = require("child_process");
-var import_node_path141 = require("path");
+var import_node_path143 = require("path");
 var import_node_util2 = require("util");
 var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process.execFile);
 var GIT_TIMEOUT_MS = 6e4;
@@ -22422,7 +22866,7 @@ async function fetchSkillFiles(params) {
   const { url, ref, skillsPath, logger: logger5 } = params;
   validateGitUrl(url, { logger: logger5 });
   validateRef(ref);
-  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path141.isAbsolute)(skillsPath)) {
+  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path143.isAbsolute)(skillsPath)) {
     throw new GitClientError(
       `Invalid skillsPath "${skillsPath}": must be a relative path without ".."`
     );
@@ -22456,7 +22900,7 @@ async function fetchSkillFiles(params) {
       timeout: GIT_TIMEOUT_MS
     });
     await execFileAsync("git", ["-C", tmpDir, "checkout"], { timeout: GIT_TIMEOUT_MS });
-    const skillsDir = (0, import_node_path141.join)(tmpDir, skillsPath);
+    const skillsDir = (0, import_node_path143.join)(tmpDir, skillsPath);
     if (!await directoryExists(skillsDir)) return [];
     return await walkDirectory(skillsDir, skillsDir, 0, { totalFiles: 0, totalSize: 0 }, logger5);
   } catch (error) {
@@ -22478,7 +22922,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
   const results = [];
   for (const name of await listDirectoryFiles(dir)) {
     if (name === ".git") continue;
-    const fullPath = (0, import_node_path141.join)(dir, name);
+    const fullPath = (0, import_node_path143.join)(dir, name);
     if (await isSymlink(fullPath)) {
       logger5?.warn(`Skipping symlink "${fullPath}".`);
       continue;
@@ -22506,7 +22950,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
         );
       }
       const content = await readFileContent(fullPath);
-      results.push({ relativePath: (0, import_node_path141.relative)(baseDir, fullPath), content, size });
+      results.push({ relativePath: (0, import_node_path143.relative)(baseDir, fullPath), content, size });
     }
   }
   return results;
@@ -22514,28 +22958,28 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
 
 // src/lib/sources-lock.ts
 var import_node_crypto = require("crypto");
-var import_node_path142 = require("path");
-var import_mini73 = require("zod/mini");
+var import_node_path144 = require("path");
+var import_mini74 = require("zod/mini");
 var LOCKFILE_VERSION = 1;
-var LockedSkillSchema = import_mini73.z.object({
-  integrity: import_mini73.z.string()
+var LockedSkillSchema = import_mini74.z.object({
+  integrity: import_mini74.z.string()
 });
-var LockedSourceSchema = import_mini73.z.object({
-  requestedRef: (0, import_mini73.optional)(import_mini73.z.string()),
-  resolvedRef: import_mini73.z.string().check((0, import_mini73.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
-  resolvedAt: (0, import_mini73.optional)(import_mini73.z.string()),
-  skills: import_mini73.z.record(import_mini73.z.string(), LockedSkillSchema)
+var LockedSourceSchema = import_mini74.z.object({
+  requestedRef: (0, import_mini74.optional)(import_mini74.z.string()),
+  resolvedRef: import_mini74.z.string().check((0, import_mini74.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
+  resolvedAt: (0, import_mini74.optional)(import_mini74.z.string()),
+  skills: import_mini74.z.record(import_mini74.z.string(), LockedSkillSchema)
 });
-var SourcesLockSchema = import_mini73.z.object({
-  lockfileVersion: import_mini73.z.number(),
-  sources: import_mini73.z.record(import_mini73.z.string(), LockedSourceSchema)
+var SourcesLockSchema = import_mini74.z.object({
+  lockfileVersion: import_mini74.z.number(),
+  sources: import_mini74.z.record(import_mini74.z.string(), LockedSourceSchema)
 });
-var LegacyLockedSourceSchema = import_mini73.z.object({
-  resolvedRef: import_mini73.z.string(),
-  skills: import_mini73.z.array(import_mini73.z.string())
+var LegacyLockedSourceSchema = import_mini74.z.object({
+  resolvedRef: import_mini74.z.string(),
+  skills: import_mini74.z.array(import_mini74.z.string())
 });
-var LegacySourcesLockSchema = import_mini73.z.object({
-  sources: import_mini73.z.record(import_mini73.z.string(), LegacyLockedSourceSchema)
+var LegacySourcesLockSchema = import_mini74.z.object({
+  sources: import_mini74.z.record(import_mini74.z.string(), LegacyLockedSourceSchema)
 });
 function migrateLegacyLock(params) {
   const { legacy, logger: logger5 } = params;
@@ -22560,7 +23004,7 @@ function createEmptyLock() {
 }
 async function readLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path142.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   if (!await fileExists(lockPath)) {
     logger5.debug("No sources lockfile found, starting fresh.");
     return createEmptyLock();
@@ -22589,7 +23033,7 @@ async function readLockFile(params) {
 }
 async function writeLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path142.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   const content = JSON.stringify(params.lock, null, 2) + "\n";
   await writeFileContent(lockPath, content);
   logger5.debug(`Wrote sources lockfile to ${lockPath}`);
@@ -22763,7 +23207,7 @@ function logGitClientHints(params) {
 async function checkLockedSkillsExist(curatedDir, skillNames) {
   if (skillNames.length === 0) return true;
   for (const name of skillNames) {
-    if (!await directoryExists((0, import_node_path143.join)(curatedDir, name))) {
+    if (!await directoryExists((0, import_node_path145.join)(curatedDir, name))) {
       return false;
     }
   }
@@ -22771,10 +23215,10 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
 }
 async function cleanPreviousCuratedSkills(params) {
   const { curatedDir, lockedSkillNames, logger: logger5 } = params;
-  const resolvedCuratedDir = (0, import_node_path143.resolve)(curatedDir);
+  const resolvedCuratedDir = (0, import_node_path145.resolve)(curatedDir);
   for (const prevSkill of lockedSkillNames) {
-    const prevDir = (0, import_node_path143.join)(curatedDir, prevSkill);
-    if (!(0, import_node_path143.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path143.sep)) {
+    const prevDir = (0, import_node_path145.join)(curatedDir, prevSkill);
+    if (!(0, import_node_path145.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path145.sep)) {
       logger5.warn(
         `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
       );
@@ -22813,9 +23257,9 @@ async function writeSkillAndComputeIntegrity(params) {
   for (const file of files) {
     checkPathTraversal({
       relativePath: file.relativePath,
-      intendedRootDir: (0, import_node_path143.join)(curatedDir, skillName)
+      intendedRootDir: (0, import_node_path145.join)(curatedDir, skillName)
     });
-    await writeFileContent((0, import_node_path143.join)(curatedDir, skillName, file.relativePath), file.content);
+    await writeFileContent((0, import_node_path145.join)(curatedDir, skillName, file.relativePath), file.content);
     written.push({ path: file.relativePath, content: file.content });
   }
   const integrity = computeSkillIntegrity(written);
@@ -22892,7 +23336,7 @@ async function fetchSource(params) {
     ref = resolvedSha;
     logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
   }
-  const curatedDir = (0, import_node_path143.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
     if (allExist) {
@@ -23017,7 +23461,7 @@ async function fetchSourceViaGit(params) {
     requestedRef = def.ref;
     resolvedSha = def.sha;
   }
-  const curatedDir = (0, import_node_path143.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     if (await checkLockedSkillsExist(curatedDir, lockedSkillNames)) {
       return { skillCount: 0, fetchedSkillNames: lockedSkillNames, updatedLock: lock };
@@ -23133,11 +23577,11 @@ async function installCommand(logger5, options) {
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini82 = require("zod/mini");
+var import_mini83 = require("zod/mini");
 
 // src/mcp/commands.ts
-var import_node_path144 = require("path");
-var import_mini74 = require("zod/mini");
+var import_node_path146 = require("path");
+var import_mini75 = require("zod/mini");
 
 // src/utils/logger.ts
 var BaseLogger = class {
@@ -23288,7 +23732,7 @@ var logger = new ConsoleLogger({ verbose: false, silent: true });
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23304,7 +23748,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23326,13 +23770,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -23351,7 +23795,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -23361,7 +23805,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(
@@ -23378,11 +23822,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -23397,12 +23841,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -23411,23 +23855,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini74.z.object({}),
-  getCommand: import_mini74.z.object({
-    relativePathFromCwd: import_mini74.z.string()
+  listCommands: import_mini75.z.object({}),
+  getCommand: import_mini75.z.object({
+    relativePathFromCwd: import_mini75.z.string()
   }),
-  putCommand: import_mini74.z.object({
-    relativePathFromCwd: import_mini74.z.string(),
+  putCommand: import_mini75.z.object({
+    relativePathFromCwd: import_mini75.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini74.z.string()
+    body: import_mini75.z.string()
   }),
-  deleteCommand: import_mini74.z.object({
-    relativePathFromCwd: import_mini74.z.string()
+  deleteCommand: import_mini75.z.object({
+    relativePathFromCwd: import_mini75.z.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${(0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${(0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -23469,15 +23913,15 @@ var commandTools = {
 };
 
 // src/mcp/generate.ts
-var import_mini75 = require("zod/mini");
-var generateOptionsSchema = import_mini75.z.object({
-  targets: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string())),
-  features: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string())),
-  delete: import_mini75.z.optional(import_mini75.z.boolean()),
-  global: import_mini75.z.optional(import_mini75.z.boolean()),
-  simulateCommands: import_mini75.z.optional(import_mini75.z.boolean()),
-  simulateSubagents: import_mini75.z.optional(import_mini75.z.boolean()),
-  simulateSkills: import_mini75.z.optional(import_mini75.z.boolean())
+var import_mini76 = require("zod/mini");
+var generateOptionsSchema = import_mini76.z.object({
+  targets: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string())),
+  features: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string())),
+  delete: import_mini76.z.optional(import_mini76.z.boolean()),
+  global: import_mini76.z.optional(import_mini76.z.boolean()),
+  simulateCommands: import_mini76.z.optional(import_mini76.z.boolean()),
+  simulateSubagents: import_mini76.z.optional(import_mini76.z.boolean()),
+  simulateSkills: import_mini76.z.optional(import_mini76.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -23556,11 +24000,11 @@ var generateTools = {
 };
 
 // src/mcp/ignore.ts
-var import_node_path145 = require("path");
-var import_mini76 = require("zod/mini");
+var import_node_path147 = require("path");
+var import_mini77 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -23577,7 +24021,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -23601,8 +24045,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const aiignorePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
-  const legacyIgnorePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const aiignorePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -23620,11 +24064,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini76.z.object({}),
-  putIgnoreFile: import_mini76.z.object({
-    content: import_mini76.z.string()
+  getIgnoreFile: import_mini77.z.object({}),
+  putIgnoreFile: import_mini77.z.object({
+    content: import_mini77.z.string()
   }),
-  deleteIgnoreFile: import_mini76.z.object({})
+  deleteIgnoreFile: import_mini77.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -23657,11 +24101,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-var import_mini77 = require("zod/mini");
-var importOptionsSchema = import_mini77.z.object({
-  target: import_mini77.z.string(),
-  features: import_mini77.z.optional(import_mini77.z.array(import_mini77.z.string())),
-  global: import_mini77.z.optional(import_mini77.z.boolean())
+var import_mini78 = require("zod/mini");
+var importOptionsSchema = import_mini78.z.object({
+  target: import_mini78.z.string(),
+  features: import_mini78.z.optional(import_mini78.z.array(import_mini78.z.string())),
+  global: import_mini78.z.optional(import_mini78.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -23732,15 +24176,15 @@ var importTools = {
 };
 
 // src/mcp/mcp.ts
-var import_node_path146 = require("path");
-var import_mini78 = require("zod/mini");
+var import_node_path148 = require("path");
+var import_mini79 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
     const rulesyncMcp = await RulesyncMcp.fromFile({
       validate: true
     });
-    const relativePathFromCwd = (0, import_node_path146.join)(
+    const relativePathFromCwd = (0, import_node_path148.join)(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -23778,7 +24222,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = (0, import_node_path146.join)(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = (0, import_node_path148.join)(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -23786,9 +24230,9 @@ async function putMcpFile({ content }) {
       fileContent: content,
       validate: true
     });
-    await ensureDir((0, import_node_path146.join)(baseDir, relativeDirPath));
+    await ensureDir((0, import_node_path148.join)(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = (0, import_node_path146.join)(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = (0, import_node_path148.join)(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -23806,15 +24250,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = (0, import_node_path146.join)(
+    const recommendedPath = (0, import_node_path148.join)(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = (0, import_node_path146.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = (0, import_node_path148.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = (0, import_node_path146.join)(
+    const relativePathFromCwd = (0, import_node_path148.join)(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -23831,11 +24275,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini78.z.object({}),
-  putMcpFile: import_mini78.z.object({
-    content: import_mini78.z.string()
+  getMcpFile: import_mini79.z.object({}),
+  putMcpFile: import_mini79.z.object({
+    content: import_mini79.z.string()
   }),
-  deleteMcpFile: import_mini78.z.object({})
+  deleteMcpFile: import_mini79.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -23868,13 +24312,13 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-var import_node_path147 = require("path");
-var import_mini79 = require("zod/mini");
+var import_node_path149 = require("path");
+var import_mini80 = require("zod/mini");
 var logger2 = new ConsoleLogger({ verbose: false, silent: true });
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23887,7 +24331,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23909,14 +24353,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -23935,7 +24379,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -23945,7 +24389,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(
@@ -23960,11 +24404,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -23979,12 +24423,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -23993,23 +24437,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini79.z.object({}),
-  getRule: import_mini79.z.object({
-    relativePathFromCwd: import_mini79.z.string()
+  listRules: import_mini80.z.object({}),
+  getRule: import_mini80.z.object({
+    relativePathFromCwd: import_mini80.z.string()
   }),
-  putRule: import_mini79.z.object({
-    relativePathFromCwd: import_mini79.z.string(),
+  putRule: import_mini80.z.object({
+    relativePathFromCwd: import_mini80.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini79.z.string()
+    body: import_mini80.z.string()
   }),
-  deleteRule: import_mini79.z.object({
-    relativePathFromCwd: import_mini79.z.string()
+  deleteRule: import_mini80.z.object({
+    relativePathFromCwd: import_mini80.z.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${(0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${(0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -24051,8 +24495,8 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-var import_node_path148 = require("path");
-var import_mini80 = require("zod/mini");
+var import_node_path150 = require("path");
+var import_mini81 = require("zod/mini");
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -24069,19 +24513,19 @@ function mcpSkillFileToAiDirFile(file) {
   };
 }
 function extractDirName(relativeDirPathFromCwd) {
-  const dirName = (0, import_node_path148.basename)(relativeDirPathFromCwd);
+  const dirName = (0, import_node_path150.basename)(relativeDirPathFromCwd);
   if (!dirName) {
     throw new Error(`Invalid path: ${relativeDirPathFromCwd}`);
   }
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs((0, import_node_path148.join)(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs((0, import_node_path150.join)(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
-        const dirName = (0, import_node_path148.basename)(dirPath);
+        const dirName = (0, import_node_path150.basename)(dirPath);
         if (!dirName) return null;
         try {
           const skill = await RulesyncSkill.fromDir({
@@ -24089,7 +24533,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -24117,7 +24561,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24151,7 +24595,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(
@@ -24168,9 +24612,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = (0, import_node_path148.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = (0, import_node_path150.join)(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -24178,15 +24622,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      const filePath = (0, import_node_path148.join)(skillDirPath, file.name);
-      const fileDir = (0, import_node_path148.join)(skillDirPath, (0, import_node_path148.dirname)(file.name));
+      const filePath = (0, import_node_path150.join)(skillDirPath, file.name);
+      const fileDir = (0, import_node_path150.join)(skillDirPath, (0, import_node_path150.dirname)(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24208,13 +24652,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -24225,29 +24669,29 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini80.z.object({
-  name: import_mini80.z.string(),
-  body: import_mini80.z.string()
+var McpSkillFileSchema = import_mini81.z.object({
+  name: import_mini81.z.string(),
+  body: import_mini81.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini80.z.object({}),
-  getSkill: import_mini80.z.object({
-    relativeDirPathFromCwd: import_mini80.z.string()
+  listSkills: import_mini81.z.object({}),
+  getSkill: import_mini81.z.object({
+    relativeDirPathFromCwd: import_mini81.z.string()
   }),
-  putSkill: import_mini80.z.object({
-    relativeDirPathFromCwd: import_mini80.z.string(),
+  putSkill: import_mini81.z.object({
+    relativeDirPathFromCwd: import_mini81.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini80.z.string(),
-    otherFiles: import_mini80.z.optional(import_mini80.z.array(McpSkillFileSchema))
+    body: import_mini81.z.string(),
+    otherFiles: import_mini81.z.optional(import_mini81.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini80.z.object({
-    relativeDirPathFromCwd: import_mini80.z.string()
+  deleteSkill: import_mini81.z.object({
+    relativeDirPathFromCwd: import_mini81.z.string()
   })
 };
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${(0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${(0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -24290,13 +24734,13 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-var import_node_path149 = require("path");
-var import_mini81 = require("zod/mini");
+var import_node_path151 = require("path");
+var import_mini82 = require("zod/mini");
 var logger4 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -24309,7 +24753,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -24333,14 +24777,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -24359,7 +24803,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -24369,7 +24813,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(
@@ -24384,11 +24828,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -24403,12 +24847,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -24420,23 +24864,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini81.z.object({}),
-  getSubagent: import_mini81.z.object({
-    relativePathFromCwd: import_mini81.z.string()
+  listSubagents: import_mini82.z.object({}),
+  getSubagent: import_mini82.z.object({
+    relativePathFromCwd: import_mini82.z.string()
   }),
-  putSubagent: import_mini81.z.object({
-    relativePathFromCwd: import_mini81.z.string(),
+  putSubagent: import_mini82.z.object({
+    relativePathFromCwd: import_mini82.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini81.z.string()
+    body: import_mini82.z.string()
   }),
-  deleteSubagent: import_mini81.z.object({
-    relativePathFromCwd: import_mini81.z.string()
+  deleteSubagent: import_mini82.z.object({
+    relativePathFromCwd: import_mini82.z.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${(0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${(0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -24478,7 +24922,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini82.z.enum([
+var rulesyncFeatureSchema = import_mini83.z.enum([
   "rule",
   "command",
   "subagent",
@@ -24488,21 +24932,21 @@ var rulesyncFeatureSchema = import_mini82.z.enum([
   "generate",
   "import"
 ]);
-var rulesyncOperationSchema = import_mini82.z.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = import_mini82.z.object({
-  name: import_mini82.z.string(),
-  body: import_mini82.z.string()
+var rulesyncOperationSchema = import_mini83.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini83.z.object({
+  name: import_mini83.z.string(),
+  body: import_mini83.z.string()
 });
-var rulesyncToolSchema = import_mini82.z.object({
+var rulesyncToolSchema = import_mini83.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini82.z.optional(import_mini82.z.string()),
-  frontmatter: import_mini82.z.optional(import_mini82.z.unknown()),
-  body: import_mini82.z.optional(import_mini82.z.string()),
-  otherFiles: import_mini82.z.optional(import_mini82.z.array(skillFileSchema)),
-  content: import_mini82.z.optional(import_mini82.z.string()),
-  generateOptions: import_mini82.z.optional(generateOptionsSchema),
-  importOptions: import_mini82.z.optional(importOptionsSchema)
+  targetPathFromCwd: import_mini83.z.optional(import_mini83.z.string()),
+  frontmatter: import_mini83.z.optional(import_mini83.z.unknown()),
+  body: import_mini83.z.optional(import_mini83.z.string()),
+  otherFiles: import_mini83.z.optional(import_mini83.z.array(skillFileSchema)),
+  content: import_mini83.z.optional(import_mini83.z.string()),
+  generateOptions: import_mini83.z.optional(generateOptionsSchema),
+  importOptions: import_mini83.z.optional(importOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -25110,7 +25554,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "7.30.0";
+var getVersion = () => "8.0.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }