rulesync 6.7.0 → 6.8.1

package/dist/index.cjs

@@ -43,7 +43,10 @@ var ALL_FEATURES = [
 var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 var FeatureSchema = import_mini.z.enum(ALL_FEATURES);
 var FeaturesSchema = import_mini.z.array(FeatureSchema);
-var RulesyncFeaturesSchema = import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD));
+var RulesyncFeaturesSchema = import_mini.z.union([
+  import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)),
+  import_mini.z.record(import_mini.z.string(), import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)))
+]);
 
 // src/utils/error.ts
 var import_zod = require("zod");
@@ -5452,7 +5455,7 @@ var OpencodeMcp = class _OpencodeMcp extends ToolMcp {
   static getSettablePaths({ global } = {}) {
     if (global) {
       return {
-        relativeDirPath: ".",
+        relativeDirPath: (0, import_node_path48.join)(".config", "opencode"),
         relativeFilePath: "opencode.json"
       };
     }
@@ -5912,7 +5915,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_toon = require("@toon-format/toon");
 var import_node_path106 = require("path");
-var import_mini48 = require("zod/mini");
+var import_mini49 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -6373,46 +6376,12 @@ var FactorydroidSkill = class _FactorydroidSkill extends SimulatedSkill {
   }
 };
 
-// src/features/skills/geminicli-skill.ts
-var import_node_path55 = require("path");
-var GeminiCliSkill = class _GeminiCliSkill extends SimulatedSkill {
-  static getSettablePaths(options) {
-    if (options?.global) {
-      throw new Error("GeminiCliSkill does not support global mode.");
-    }
-    return {
-      relativeDirPath: (0, import_node_path55.join)(".gemini", "skills")
-    };
-  }
-  static async fromDir(params) {
-    const baseParams = await this.fromDirDefault(params);
-    return new _GeminiCliSkill(baseParams);
-  }
-  static fromRulesyncSkill(params) {
-    const baseParams = {
-      ...this.fromRulesyncSkillDefault(params),
-      relativeDirPath: this.getSettablePaths().relativeDirPath
-    };
-    return new _GeminiCliSkill(baseParams);
-  }
-  static isTargetedByRulesyncSkill(rulesyncSkill) {
-    return this.isTargetedByRulesyncSkillDefault({
-      rulesyncSkill,
-      toolTarget: "geminicli"
-    });
-  }
-  static forDeletion(params) {
-    const baseParams = this.forDeletionDefault(params);
-    return new _GeminiCliSkill(baseParams);
-  }
-};
-
 // src/features/skills/skills-processor.ts
 var import_node_path69 = require("path");
-var import_mini33 = require("zod/mini");
+var import_mini34 = require("zod/mini");
 
 // src/types/dir-feature-processor.ts
-var import_node_path56 = require("path");
+var import_node_path55 = require("path");
 var DirFeatureProcessor = class {
   baseDir;
   dryRun;
@@ -6429,6 +6398,10 @@ var DirFeatureProcessor = class {
   /**
    * Once converted to rulesync/tool dirs, write them to the filesystem.
    * Returns the number of directories written.
+   *
+   * Note: This method uses directory-level change detection. If any file within
+   * a directory has changed, ALL files in that directory are rewritten. This is
+   * an intentional design decision to ensure consistency within directory units.
    */
   async writeAiDirs(aiDirs) {
     let changedCount = 0;
@@ -6438,7 +6411,7 @@ var DirFeatureProcessor = class {
       const mainFile = aiDir.getMainFile();
       let mainFileContent;
       if (mainFile) {
-        const mainFilePath = (0, import_node_path56.join)(dirPath, mainFile.name);
+        const mainFilePath = (0, import_node_path55.join)(dirPath, mainFile.name);
         const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
         mainFileContent = addTrailingNewline(content);
         const existingContent = await readFileContentOrNull(mainFilePath);
@@ -6452,7 +6425,7 @@ var DirFeatureProcessor = class {
         const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
         otherFileContents.push(contentWithNewline);
         if (!dirHasChanges) {
-          const filePath = (0, import_node_path56.join)(dirPath, file.relativeFilePathToDirPath);
+          const filePath = (0, import_node_path55.join)(dirPath, file.relativeFilePathToDirPath);
           const existingContent = await readFileContentOrNull(filePath);
           if (existingContent !== contentWithNewline) {
             dirHasChanges = true;
@@ -6465,20 +6438,25 @@ var DirFeatureProcessor = class {
       if (this.dryRun) {
         logger.info(`[DRY RUN] Would create directory: ${dirPath}`);
         if (mainFile) {
-          logger.info(`[DRY RUN] Would write: ${(0, import_node_path56.join)(dirPath, mainFile.name)}`);
+          logger.info(`[DRY RUN] Would write: ${(0, import_node_path55.join)(dirPath, mainFile.name)}`);
         }
         for (const file of otherFiles) {
-          logger.info(`[DRY RUN] Would write: ${(0, import_node_path56.join)(dirPath, file.relativeFilePathToDirPath)}`);
+          logger.info(`[DRY RUN] Would write: ${(0, import_node_path55.join)(dirPath, file.relativeFilePathToDirPath)}`);
         }
       } else {
         await ensureDir(dirPath);
         if (mainFile && mainFileContent) {
-          const mainFilePath = (0, import_node_path56.join)(dirPath, mainFile.name);
+          const mainFilePath = (0, import_node_path55.join)(dirPath, mainFile.name);
           await writeFileContent(mainFilePath, mainFileContent);
         }
         for (const [i, file] of otherFiles.entries()) {
-          const filePath = (0, import_node_path56.join)(dirPath, file.relativeFilePathToDirPath);
-          const content = otherFileContents[i] ?? "";
+          const filePath = (0, import_node_path55.join)(dirPath, file.relativeFilePathToDirPath);
+          const content = otherFileContents[i];
+          if (content === void 0) {
+            throw new Error(
+              `Internal error: content for file ${file.relativeFilePathToDirPath} is undefined. This indicates a synchronization issue between otherFiles and otherFileContents arrays.`
+            );
+          }
           await writeFileContent(filePath, content);
         }
       }
@@ -6511,11 +6489,11 @@ var DirFeatureProcessor = class {
 };
 
 // src/features/skills/agentsskills-skill.ts
-var import_node_path58 = require("path");
+var import_node_path57 = require("path");
 var import_mini22 = require("zod/mini");
 
 // src/features/skills/rulesync-skill.ts
-var import_node_path57 = require("path");
+var import_node_path56 = require("path");
 var import_mini21 = require("zod/mini");
 var RulesyncSkillFrontmatterSchemaInternal = import_mini21.z.looseObject({
   name: import_mini21.z.string(),
@@ -6607,8 +6585,8 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
     dirName,
     global = false
   }) {
-    const skillDirPath = (0, import_node_path57.join)(baseDir, relativeDirPath, dirName);
-    const skillFilePath = (0, import_node_path57.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillDirPath = (0, import_node_path56.join)(baseDir, relativeDirPath, dirName);
+    const skillFilePath = (0, import_node_path56.join)(skillDirPath, SKILL_FILE_NAME);
     if (!await fileExists(skillFilePath)) {
       throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
     }
@@ -6645,7 +6623,7 @@ var AgentsSkillsSkillFrontmatterSchema = import_mini22.z.looseObject({
 var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path58.join)(".agents", "skills"),
+    relativeDirPath = (0, import_node_path57.join)(".agents", "skills"),
     dirName,
     frontmatter,
     body,
@@ -6677,7 +6655,7 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
       throw new Error("AgentsSkillsSkill does not support global mode.");
     }
     return {
-      relativeDirPath: (0, import_node_path58.join)(".agents", "skills")
+      relativeDirPath: (0, import_node_path57.join)(".agents", "skills")
     };
   }
   getFrontmatter() {
@@ -6759,9 +6737,9 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
     });
     const result = AgentsSkillsSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = (0, import_node_path58.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = (0, import_node_path57.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path58.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${(0, import_node_path57.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _AgentsSkillsSkill({
@@ -6796,7 +6774,7 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
 };
 
 // src/features/skills/antigravity-skill.ts
-var import_node_path59 = require("path");
+var import_node_path58 = require("path");
 var import_mini23 = require("zod/mini");
 var AntigravitySkillFrontmatterSchema = import_mini23.z.looseObject({
   name: import_mini23.z.string(),
@@ -6805,7 +6783,7 @@ var AntigravitySkillFrontmatterSchema = import_mini23.z.looseObject({
 var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path59.join)(".agent", "skills"),
+    relativeDirPath = (0, import_node_path58.join)(".agent", "skills"),
     dirName,
     frontmatter,
     body,
@@ -6837,11 +6815,11 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
   } = {}) {
     if (global) {
       return {
-        relativeDirPath: (0, import_node_path59.join)(".gemini", "antigravity", "skills")
+        relativeDirPath: (0, import_node_path58.join)(".gemini", "antigravity", "skills")
       };
     }
     return {
-      relativeDirPath: (0, import_node_path59.join)(".agent", "skills")
+      relativeDirPath: (0, import_node_path58.join)(".agent", "skills")
     };
   }
   getFrontmatter() {
@@ -6923,9 +6901,9 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
     });
     const result = AntigravitySkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = (0, import_node_path59.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = (0, import_node_path58.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path59.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${(0, import_node_path58.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _AntigravitySkill({
@@ -6959,7 +6937,7 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
 };
 
 // src/features/skills/claudecode-skill.ts
-var import_node_path60 = require("path");
+var import_node_path59 = require("path");
 var import_mini24 = require("zod/mini");
 var ClaudecodeSkillFrontmatterSchema = import_mini24.z.looseObject({
   name: import_mini24.z.string(),
@@ -6969,7 +6947,7 @@ var ClaudecodeSkillFrontmatterSchema = import_mini24.z.looseObject({
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path60.join)(".claude", "skills"),
+    relativeDirPath = (0, import_node_path59.join)(".claude", "skills"),
     dirName,
     frontmatter,
     body,
@@ -7000,7 +6978,7 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
     global: _global = false
   } = {}) {
     return {
-      relativeDirPath: (0, import_node_path60.join)(".claude", "skills")
+      relativeDirPath: (0, import_node_path59.join)(".claude", "skills")
     };
   }
   getFrontmatter() {
@@ -7088,9 +7066,9 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
     });
     const result = ClaudecodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = (0, import_node_path60.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = (0, import_node_path59.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path60.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${(0, import_node_path59.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _ClaudecodeSkill({
@@ -7124,7 +7102,7 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
 };
 
 // src/features/skills/codexcli-skill.ts
-var import_node_path61 = require("path");
+var import_node_path60 = require("path");
 var import_mini25 = require("zod/mini");
 var CodexCliSkillFrontmatterSchema = import_mini25.z.looseObject({
   name: import_mini25.z.string(),
@@ -7138,7 +7116,7 @@ var CodexCliSkillFrontmatterSchema = import_mini25.z.looseObject({
 var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path61.join)(".codex", "skills"),
+    relativeDirPath = (0, import_node_path60.join)(".codex", "skills"),
     dirName,
     frontmatter,
     body,
@@ -7169,7 +7147,7 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
     global: _global = false
   } = {}) {
     return {
-      relativeDirPath: (0, import_node_path61.join)(".codex", "skills")
+      relativeDirPath: (0, import_node_path60.join)(".codex", "skills")
     };
   }
   getFrontmatter() {
@@ -7261,9 +7239,9 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
     });
     const result = CodexCliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = (0, import_node_path61.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = (0, import_node_path60.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path61.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${(0, import_node_path60.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _CodexCliSkill({
@@ -7297,7 +7275,7 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
 };
 
 // src/features/skills/copilot-skill.ts
-var import_node_path62 = require("path");
+var import_node_path61 = require("path");
 var import_mini26 = require("zod/mini");
 var CopilotSkillFrontmatterSchema = import_mini26.z.looseObject({
   name: import_mini26.z.string(),
@@ -7307,7 +7285,7 @@ var CopilotSkillFrontmatterSchema = import_mini26.z.looseObject({
 var CopilotSkill = class _CopilotSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path62.join)(".github", "skills"),
+    relativeDirPath = (0, import_node_path61.join)(".github", "skills"),
     dirName,
     frontmatter,
     body,
@@ -7339,7 +7317,7 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
       throw new Error("CopilotSkill does not support global mode.");
     }
     return {
-      relativeDirPath: (0, import_node_path62.join)(".github", "skills")
+      relativeDirPath: (0, import_node_path61.join)(".github", "skills")
     };
   }
   getFrontmatter() {
@@ -7427,9 +7405,9 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
     });
     const result = CopilotSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = (0, import_node_path62.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = (0, import_node_path61.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path62.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${(0, import_node_path61.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _CopilotSkill({
@@ -7464,7 +7442,7 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
 };
 
 // src/features/skills/cursor-skill.ts
-var import_node_path63 = require("path");
+var import_node_path62 = require("path");
 var import_mini27 = require("zod/mini");
 var CursorSkillFrontmatterSchema = import_mini27.z.looseObject({
   name: import_mini27.z.string(),
@@ -7473,7 +7451,7 @@ var CursorSkillFrontmatterSchema = import_mini27.z.looseObject({
 var CursorSkill = class _CursorSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path63.join)(".cursor", "skills"),
+    relativeDirPath = (0, import_node_path62.join)(".cursor", "skills"),
     dirName,
     frontmatter,
     body,
@@ -7502,7 +7480,7 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
   }
   static getSettablePaths(_options) {
     return {
-      relativeDirPath: (0, import_node_path63.join)(".cursor", "skills")
+      relativeDirPath: (0, import_node_path62.join)(".cursor", "skills")
     };
   }
   getFrontmatter() {
@@ -7584,9 +7562,9 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
     });
     const result = CursorSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = (0, import_node_path63.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = (0, import_node_path62.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path63.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${(0, import_node_path62.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _CursorSkill({
@@ -7620,13 +7598,172 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
   }
 };
 
-// src/features/skills/kilo-skill.ts
-var import_node_path64 = require("path");
+// src/features/skills/geminicli-skill.ts
+var import_node_path63 = require("path");
 var import_mini28 = require("zod/mini");
-var KiloSkillFrontmatterSchema = import_mini28.z.looseObject({
+var GeminiCliSkillFrontmatterSchema = import_mini28.z.looseObject({
   name: import_mini28.z.string(),
   description: import_mini28.z.string()
 });
+var GeminiCliSkill = class _GeminiCliSkill extends ToolSkill {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = _GeminiCliSkill.getSettablePaths().relativeDirPath,
+    dirName,
+    frontmatter,
+    body,
+    otherFiles = [],
+    validate = true,
+    global = false
+  }) {
+    super({
+      baseDir,
+      relativeDirPath,
+      dirName,
+      mainFile: {
+        name: SKILL_FILE_NAME,
+        body,
+        frontmatter: { ...frontmatter }
+      },
+      otherFiles,
+      global
+    });
+    if (validate) {
+      const result = this.validate();
+      if (!result.success) {
+        throw result.error;
+      }
+    }
+  }
+  static getSettablePaths({
+    global: _global = false
+  } = {}) {
+    return {
+      relativeDirPath: (0, import_node_path63.join)(".gemini", "skills")
+    };
+  }
+  getFrontmatter() {
+    if (!this.mainFile?.frontmatter) {
+      throw new Error("Frontmatter is not defined");
+    }
+    const result = GeminiCliSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
+    return result;
+  }
+  getBody() {
+    return this.mainFile?.body ?? "";
+  }
+  validate() {
+    if (this.mainFile === void 0) {
+      return {
+        success: false,
+        error: new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+      };
+    }
+    const result = GeminiCliSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
+    if (!result.success) {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`
+        )
+      };
+    }
+    return { success: true, error: null };
+  }
+  toRulesyncSkill() {
+    const frontmatter = this.getFrontmatter();
+    const rulesyncFrontmatter = {
+      name: frontmatter.name,
+      description: frontmatter.description,
+      targets: ["*"]
+    };
+    return new RulesyncSkill({
+      baseDir: this.baseDir,
+      relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+      dirName: this.getDirName(),
+      frontmatter: rulesyncFrontmatter,
+      body: this.getBody(),
+      otherFiles: this.getOtherFiles(),
+      validate: true,
+      global: this.global
+    });
+  }
+  static fromRulesyncSkill({
+    rulesyncSkill,
+    validate = true,
+    global = false
+  }) {
+    const settablePaths = _GeminiCliSkill.getSettablePaths({ global });
+    const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+    const geminiCliFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description
+    };
+    return new _GeminiCliSkill({
+      baseDir: rulesyncSkill.getBaseDir(),
+      relativeDirPath: settablePaths.relativeDirPath,
+      dirName: rulesyncSkill.getDirName(),
+      frontmatter: geminiCliFrontmatter,
+      body: rulesyncSkill.getBody(),
+      otherFiles: rulesyncSkill.getOtherFiles(),
+      validate,
+      global
+    });
+  }
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    const targets = rulesyncSkill.getFrontmatter().targets;
+    return targets.includes("*") || targets.includes("geminicli");
+  }
+  static async fromDir(params) {
+    const loaded = await this.loadSkillDirContent({
+      ...params,
+      getSettablePaths: _GeminiCliSkill.getSettablePaths
+    });
+    const result = GeminiCliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+    if (!result.success) {
+      const skillDirPath = (0, import_node_path63.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      throw new Error(
+        `Invalid frontmatter in ${(0, import_node_path63.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+      );
+    }
+    return new _GeminiCliSkill({
+      baseDir: loaded.baseDir,
+      relativeDirPath: loaded.relativeDirPath,
+      dirName: loaded.dirName,
+      frontmatter: result.data,
+      body: loaded.body,
+      otherFiles: loaded.otherFiles,
+      validate: true,
+      global: loaded.global
+    });
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName,
+    global = false
+  }) {
+    const settablePaths = _GeminiCliSkill.getSettablePaths({ global });
+    return new _GeminiCliSkill({
+      baseDir,
+      relativeDirPath: relativeDirPath ?? settablePaths.relativeDirPath,
+      dirName,
+      frontmatter: { name: "", description: "" },
+      body: "",
+      otherFiles: [],
+      validate: false,
+      global
+    });
+  }
+};
+
+// src/features/skills/kilo-skill.ts
+var import_node_path64 = require("path");
+var import_mini29 = require("zod/mini");
+var KiloSkillFrontmatterSchema = import_mini29.z.looseObject({
+  name: import_mini29.z.string(),
+  description: import_mini29.z.string()
+});
 var KiloSkill = class _KiloSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
@@ -7799,10 +7936,10 @@ var KiloSkill = class _KiloSkill extends ToolSkill {
 
 // src/features/skills/kiro-skill.ts
 var import_node_path65 = require("path");
-var import_mini29 = require("zod/mini");
-var KiroSkillFrontmatterSchema = import_mini29.z.looseObject({
-  name: import_mini29.z.string(),
-  description: import_mini29.z.string()
+var import_mini30 = require("zod/mini");
+var KiroSkillFrontmatterSchema = import_mini30.z.looseObject({
+  name: import_mini30.z.string(),
+  description: import_mini30.z.string()
 });
 var KiroSkill = class _KiroSkill extends ToolSkill {
   constructor({
@@ -7978,11 +8115,11 @@ var KiroSkill = class _KiroSkill extends ToolSkill {
 
 // src/features/skills/opencode-skill.ts
 var import_node_path66 = require("path");
-var import_mini30 = require("zod/mini");
-var OpenCodeSkillFrontmatterSchema = import_mini30.z.looseObject({
-  name: import_mini30.z.string(),
-  description: import_mini30.z.string(),
-  "allowed-tools": import_mini30.z.optional(import_mini30.z.array(import_mini30.z.string()))
+var import_mini31 = require("zod/mini");
+var OpenCodeSkillFrontmatterSchema = import_mini31.z.looseObject({
+  name: import_mini31.z.string(),
+  description: import_mini31.z.string(),
+  "allowed-tools": import_mini31.z.optional(import_mini31.z.array(import_mini31.z.string()))
 });
 var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
   constructor({
@@ -8141,10 +8278,10 @@ var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
 
 // src/features/skills/replit-skill.ts
 var import_node_path67 = require("path");
-var import_mini31 = require("zod/mini");
-var ReplitSkillFrontmatterSchema = import_mini31.z.looseObject({
-  name: import_mini31.z.string(),
-  description: import_mini31.z.string()
+var import_mini32 = require("zod/mini");
+var ReplitSkillFrontmatterSchema = import_mini32.z.looseObject({
+  name: import_mini32.z.string(),
+  description: import_mini32.z.string()
 });
 var ReplitSkill = class _ReplitSkill extends ToolSkill {
   constructor({
@@ -8301,10 +8438,10 @@ var ReplitSkill = class _ReplitSkill extends ToolSkill {
 
 // src/features/skills/roo-skill.ts
 var import_node_path68 = require("path");
-var import_mini32 = require("zod/mini");
-var RooSkillFrontmatterSchema = import_mini32.z.looseObject({
-  name: import_mini32.z.string(),
-  description: import_mini32.z.string()
+var import_mini33 = require("zod/mini");
+var RooSkillFrontmatterSchema = import_mini33.z.looseObject({
+  name: import_mini33.z.string(),
+  description: import_mini33.z.string()
 });
 var RooSkill = class _RooSkill extends ToolSkill {
   constructor({
@@ -8494,7 +8631,7 @@ var skillsProcessorToolTargetTuple = [
   "replit",
   "roo"
 ];
-var SkillsProcessorToolTargetSchema = import_mini33.z.enum(skillsProcessorToolTargetTuple);
+var SkillsProcessorToolTargetSchema = import_mini34.z.enum(skillsProcessorToolTargetTuple);
 var toolSkillFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -8563,7 +8700,7 @@ var toolSkillFactories = /* @__PURE__ */ new Map([
     "geminicli",
     {
       class: GeminiCliSkill,
-      meta: { supportsProject: true, supportsSimulated: true, supportsGlobal: false }
+      meta: { supportsProject: true, supportsSimulated: false, supportsGlobal: true }
     }
   ],
   [
@@ -8783,7 +8920,7 @@ var import_node_path71 = require("path");
 
 // src/features/subagents/simulated-subagent.ts
 var import_node_path70 = require("path");
-var import_mini34 = require("zod/mini");
+var import_mini35 = require("zod/mini");
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -8826,9 +8963,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = import_mini34.z.object({
-  name: import_mini34.z.string(),
-  description: import_mini34.z.string()
+var SimulatedSubagentFrontmatterSchema = import_mini35.z.object({
+  name: import_mini35.z.string(),
+  description: import_mini35.z.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -9067,19 +9204,19 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path82 = require("path");
-var import_mini41 = require("zod/mini");
+var import_mini42 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
 var import_node_path77 = require("path");
-var import_mini36 = require("zod/mini");
+var import_mini37 = require("zod/mini");
 
 // src/features/subagents/rulesync-subagent.ts
 var import_node_path76 = require("path");
-var import_mini35 = require("zod/mini");
-var RulesyncSubagentFrontmatterSchema = import_mini35.z.looseObject({
-  targets: import_mini35.z._default(RulesyncTargetsSchema, ["*"]),
-  name: import_mini35.z.string(),
-  description: import_mini35.z.string()
+var import_mini36 = require("zod/mini");
+var RulesyncSubagentFrontmatterSchema = import_mini36.z.looseObject({
+  targets: import_mini36.z._default(RulesyncTargetsSchema, ["*"]),
+  name: import_mini36.z.string(),
+  description: import_mini36.z.string()
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -9149,13 +9286,13 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = import_mini36.z.looseObject({
-  name: import_mini36.z.string(),
-  description: import_mini36.z.string(),
-  model: import_mini36.z.optional(import_mini36.z.string()),
-  tools: import_mini36.z.optional(import_mini36.z.union([import_mini36.z.string(), import_mini36.z.array(import_mini36.z.string())])),
-  permissionMode: import_mini36.z.optional(import_mini36.z.string()),
-  skills: import_mini36.z.optional(import_mini36.z.union([import_mini36.z.string(), import_mini36.z.array(import_mini36.z.string())]))
+var ClaudecodeSubagentFrontmatterSchema = import_mini37.z.looseObject({
+  name: import_mini37.z.string(),
+  description: import_mini37.z.string(),
+  model: import_mini37.z.optional(import_mini37.z.string()),
+  tools: import_mini37.z.optional(import_mini37.z.union([import_mini37.z.string(), import_mini37.z.array(import_mini37.z.string())])),
+  permissionMode: import_mini37.z.optional(import_mini37.z.string()),
+  skills: import_mini37.z.optional(import_mini37.z.union([import_mini37.z.string(), import_mini37.z.array(import_mini37.z.string())]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -9305,12 +9442,12 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 
 // src/features/subagents/copilot-subagent.ts
 var import_node_path78 = require("path");
-var import_mini37 = require("zod/mini");
+var import_mini38 = require("zod/mini");
 var REQUIRED_TOOL = "agent/runSubagent";
-var CopilotSubagentFrontmatterSchema = import_mini37.z.looseObject({
-  name: import_mini37.z.string(),
-  description: import_mini37.z.string(),
-  tools: import_mini37.z.optional(import_mini37.z.union([import_mini37.z.string(), import_mini37.z.array(import_mini37.z.string())]))
+var CopilotSubagentFrontmatterSchema = import_mini38.z.looseObject({
+  name: import_mini38.z.string(),
+  description: import_mini38.z.string(),
+  tools: import_mini38.z.optional(import_mini38.z.union([import_mini38.z.string(), import_mini38.z.array(import_mini38.z.string())]))
 });
 var normalizeTools = (tools) => {
   if (!tools) {
@@ -9471,10 +9608,10 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
 
 // src/features/subagents/cursor-subagent.ts
 var import_node_path79 = require("path");
-var import_mini38 = require("zod/mini");
-var CursorSubagentFrontmatterSchema = import_mini38.z.looseObject({
-  name: import_mini38.z.string(),
-  description: import_mini38.z.string()
+var import_mini39 = require("zod/mini");
+var CursorSubagentFrontmatterSchema = import_mini39.z.looseObject({
+  name: import_mini39.z.string(),
+  description: import_mini39.z.string()
 });
 var CursorSubagent = class _CursorSubagent extends ToolSubagent {
   frontmatter;
@@ -9618,22 +9755,22 @@ var CursorSubagent = class _CursorSubagent extends ToolSubagent {
 
 // src/features/subagents/kiro-subagent.ts
 var import_node_path80 = require("path");
-var import_mini39 = require("zod/mini");
-var KiroCliSubagentJsonSchema = import_mini39.z.looseObject({
-  name: import_mini39.z.string(),
-  description: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.string())),
-  prompt: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.string())),
-  tools: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.array(import_mini39.z.string()))),
-  toolAliases: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.record(import_mini39.z.string(), import_mini39.z.string()))),
-  toolSettings: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.unknown())),
-  toolSchema: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.unknown())),
-  hooks: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.record(import_mini39.z.string(), import_mini39.z.array(import_mini39.z.unknown())))),
-  model: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.string())),
-  mcpServers: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.record(import_mini39.z.string(), import_mini39.z.unknown()))),
-  useLegacyMcpJson: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.boolean())),
-  resources: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.array(import_mini39.z.string()))),
-  allowedTools: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.array(import_mini39.z.string()))),
-  includeMcpJson: import_mini39.z.optional(import_mini39.z.nullable(import_mini39.z.boolean()))
+var import_mini40 = require("zod/mini");
+var KiroCliSubagentJsonSchema = import_mini40.z.looseObject({
+  name: import_mini40.z.string(),
+  description: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.string())),
+  prompt: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.string())),
+  tools: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.array(import_mini40.z.string()))),
+  toolAliases: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.record(import_mini40.z.string(), import_mini40.z.string()))),
+  toolSettings: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.unknown())),
+  toolSchema: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.unknown())),
+  hooks: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.record(import_mini40.z.string(), import_mini40.z.array(import_mini40.z.unknown())))),
+  model: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.string())),
+  mcpServers: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.record(import_mini40.z.string(), import_mini40.z.unknown()))),
+  useLegacyMcpJson: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.boolean())),
+  resources: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.array(import_mini40.z.string()))),
+  allowedTools: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.array(import_mini40.z.string()))),
+  includeMcpJson: import_mini40.z.optional(import_mini40.z.nullable(import_mini40.z.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -9755,11 +9892,11 @@ var KiroSubagent = class _KiroSubagent extends ToolSubagent {
 
 // src/features/subagents/opencode-subagent.ts
 var import_node_path81 = require("path");
-var import_mini40 = require("zod/mini");
-var OpenCodeSubagentFrontmatterSchema = import_mini40.z.looseObject({
-  description: import_mini40.z.string(),
-  mode: import_mini40.z.literal("subagent"),
-  name: import_mini40.z.optional(import_mini40.z.string())
+var import_mini41 = require("zod/mini");
+var OpenCodeSubagentFrontmatterSchema = import_mini41.z.looseObject({
+  description: import_mini41.z.string(),
+  mode: import_mini41.z.literal("subagent"),
+  name: import_mini41.z.optional(import_mini41.z.string())
 });
 var OpenCodeSubagent = class _OpenCodeSubagent extends ToolSubagent {
   frontmatter;
@@ -9915,7 +10052,7 @@ var subagentsProcessorToolTargetTuple = [
   "opencode",
   "roo"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini41.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini42.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -10192,42 +10329,42 @@ var import_node_path84 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path83 = require("path");
-var import_mini42 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini42.z.object({
-  root: import_mini42.z.optional(import_mini42.z.boolean()),
-  localRoot: import_mini42.z.optional(import_mini42.z.boolean()),
-  targets: import_mini42.z._default(RulesyncTargetsSchema, ["*"]),
-  description: import_mini42.z.optional(import_mini42.z.string()),
-  globs: import_mini42.z.optional(import_mini42.z.array(import_mini42.z.string())),
-  agentsmd: import_mini42.z.optional(
-    import_mini42.z.object({
+var import_mini43 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini43.z.object({
+  root: import_mini43.z.optional(import_mini43.z.boolean()),
+  localRoot: import_mini43.z.optional(import_mini43.z.boolean()),
+  targets: import_mini43.z._default(RulesyncTargetsSchema, ["*"]),
+  description: import_mini43.z.optional(import_mini43.z.string()),
+  globs: import_mini43.z.optional(import_mini43.z.array(import_mini43.z.string())),
+  agentsmd: import_mini43.z.optional(
+    import_mini43.z.object({
       // @example "path/to/subproject"
-      subprojectPath: import_mini42.z.optional(import_mini42.z.string())
+      subprojectPath: import_mini43.z.optional(import_mini43.z.string())
     })
   ),
-  claudecode: import_mini42.z.optional(
-    import_mini42.z.object({
+  claudecode: import_mini43.z.optional(
+    import_mini43.z.object({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example ["src/**/*.ts", "tests/**/*.test.ts"]
-      paths: import_mini42.z.optional(import_mini42.z.array(import_mini42.z.string()))
+      paths: import_mini43.z.optional(import_mini43.z.array(import_mini43.z.string()))
     })
   ),
-  cursor: import_mini42.z.optional(
-    import_mini42.z.object({
-      alwaysApply: import_mini42.z.optional(import_mini42.z.boolean()),
-      description: import_mini42.z.optional(import_mini42.z.string()),
-      globs: import_mini42.z.optional(import_mini42.z.array(import_mini42.z.string()))
+  cursor: import_mini43.z.optional(
+    import_mini43.z.object({
+      alwaysApply: import_mini43.z.optional(import_mini43.z.boolean()),
+      description: import_mini43.z.optional(import_mini43.z.string()),
+      globs: import_mini43.z.optional(import_mini43.z.array(import_mini43.z.string()))
     })
   ),
-  copilot: import_mini42.z.optional(
-    import_mini42.z.object({
-      excludeAgent: import_mini42.z.optional(import_mini42.z.union([import_mini42.z.literal("code-review"), import_mini42.z.literal("coding-agent")]))
+  copilot: import_mini43.z.optional(
+    import_mini43.z.object({
+      excludeAgent: import_mini43.z.optional(import_mini43.z.union([import_mini43.z.literal("code-review"), import_mini43.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini42.z.optional(
-    import_mini42.z.looseObject({
-      trigger: import_mini42.z.optional(import_mini42.z.string()),
-      globs: import_mini42.z.optional(import_mini42.z.array(import_mini42.z.string()))
+  antigravity: import_mini43.z.optional(
+    import_mini43.z.looseObject({
+      trigger: import_mini43.z.optional(import_mini43.z.string()),
+      globs: import_mini43.z.optional(import_mini43.z.array(import_mini43.z.string()))
     })
   )
 });
@@ -10530,20 +10667,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path86 = require("path");
-var import_mini43 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini43.z.looseObject({
-  trigger: import_mini43.z.optional(
-    import_mini43.z.union([
-      import_mini43.z.literal("always_on"),
-      import_mini43.z.literal("glob"),
-      import_mini43.z.literal("manual"),
-      import_mini43.z.literal("model_decision"),
-      import_mini43.z.string()
+var import_mini44 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini44.z.looseObject({
+  trigger: import_mini44.z.optional(
+    import_mini44.z.union([
+      import_mini44.z.literal("always_on"),
+      import_mini44.z.literal("glob"),
+      import_mini44.z.literal("manual"),
+      import_mini44.z.literal("model_decision"),
+      import_mini44.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini43.z.optional(import_mini43.z.string()),
-  description: import_mini43.z.optional(import_mini43.z.string())
+  globs: import_mini44.z.optional(import_mini44.z.string()),
+  description: import_mini44.z.optional(import_mini44.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -11122,9 +11259,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path90 = require("path");
-var import_mini44 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini44.z.object({
-  paths: import_mini44.z.optional(import_mini44.z.array(import_mini44.z.string()))
+var import_mini45 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini45.z.object({
+  paths: import_mini45.z.optional(import_mini45.z.array(import_mini45.z.string()))
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -11333,9 +11470,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path91 = require("path");
-var import_mini45 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini45.z.object({
-  description: import_mini45.z.string()
+var import_mini46 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini46.z.object({
+  description: import_mini46.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths(_options = {}) {
@@ -11514,11 +11651,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path93 = require("path");
-var import_mini46 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini46.z.object({
-  description: import_mini46.z.optional(import_mini46.z.string()),
-  applyTo: import_mini46.z.optional(import_mini46.z.string()),
-  excludeAgent: import_mini46.z.optional(import_mini46.z.union([import_mini46.z.literal("code-review"), import_mini46.z.literal("coding-agent")]))
+var import_mini47 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini47.z.object({
+  description: import_mini47.z.optional(import_mini47.z.string()),
+  applyTo: import_mini47.z.optional(import_mini47.z.string()),
+  excludeAgent: import_mini47.z.optional(import_mini47.z.union([import_mini47.z.literal("code-review"), import_mini47.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -11702,11 +11839,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path94 = require("path");
-var import_mini47 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini47.z.object({
-  description: import_mini47.z.optional(import_mini47.z.string()),
-  globs: import_mini47.z.optional(import_mini47.z.string()),
-  alwaysApply: import_mini47.z.optional(import_mini47.z.boolean())
+var import_mini48 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini48.z.object({
+  description: import_mini48.z.optional(import_mini48.z.string()),
+  globs: import_mini48.z.optional(import_mini48.z.string()),
+  alwaysApply: import_mini48.z.optional(import_mini48.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -12813,7 +12950,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini48.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini49.z.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -12934,8 +13071,7 @@ var toolRuleFactories = /* @__PURE__ */ new Map([
         supportsGlobal: true,
         ruleDiscoveryMode: "toon",
         additionalConventions: {
-          subagents: { subagentClass: GeminiCliSubagent },
-          skills: { skillClass: GeminiCliSkill }
+          subagents: { subagentClass: GeminiCliSubagent }
         }
       }
     }
@@ -13515,60 +13651,60 @@ ${toonContent}`;
 };
 
 // src/types/git-provider.ts
-var import_mini49 = require("zod/mini");
+var import_mini50 = require("zod/mini");
 var ALL_GIT_PROVIDERS = ["github", "gitlab"];
-var GitProviderSchema = import_mini49.z.enum(ALL_GIT_PROVIDERS);
+var GitProviderSchema = import_mini50.z.enum(ALL_GIT_PROVIDERS);
 
 // src/lib/github-client.ts
 var import_request_error = require("@octokit/request-error");
 var import_rest = require("@octokit/rest");
 
 // src/types/fetch.ts
-var import_mini51 = require("zod/mini");
+var import_mini52 = require("zod/mini");
 
 // src/types/fetch-targets.ts
-var import_mini50 = require("zod/mini");
+var import_mini51 = require("zod/mini");
 var ALL_FETCH_TARGETS = ["rulesync", ...ALL_TOOL_TARGETS];
-var FetchTargetSchema = import_mini50.z.enum(ALL_FETCH_TARGETS);
+var FetchTargetSchema = import_mini51.z.enum(ALL_FETCH_TARGETS);
 
 // src/types/fetch.ts
-var ConflictStrategySchema = import_mini51.z.enum(["skip", "overwrite"]);
-var GitHubFileTypeSchema = import_mini51.z.enum(["file", "dir", "symlink", "submodule"]);
-var GitHubFileEntrySchema = import_mini51.z.looseObject({
-  name: import_mini51.z.string(),
-  path: import_mini51.z.string(),
-  sha: import_mini51.z.string(),
-  size: import_mini51.z.number(),
+var ConflictStrategySchema = import_mini52.z.enum(["skip", "overwrite"]);
+var GitHubFileTypeSchema = import_mini52.z.enum(["file", "dir", "symlink", "submodule"]);
+var GitHubFileEntrySchema = import_mini52.z.looseObject({
+  name: import_mini52.z.string(),
+  path: import_mini52.z.string(),
+  sha: import_mini52.z.string(),
+  size: import_mini52.z.number(),
   type: GitHubFileTypeSchema,
-  download_url: import_mini51.z.nullable(import_mini51.z.string())
+  download_url: import_mini52.z.nullable(import_mini52.z.string())
 });
-var FetchOptionsSchema = import_mini51.z.looseObject({
-  target: import_mini51.z.optional(FetchTargetSchema),
-  features: import_mini51.z.optional(import_mini51.z.array(import_mini51.z.enum(ALL_FEATURES_WITH_WILDCARD))),
-  ref: import_mini51.z.optional(import_mini51.z.string()),
-  path: import_mini51.z.optional(import_mini51.z.string()),
-  output: import_mini51.z.optional(import_mini51.z.string()),
-  conflict: import_mini51.z.optional(ConflictStrategySchema),
-  token: import_mini51.z.optional(import_mini51.z.string()),
-  verbose: import_mini51.z.optional(import_mini51.z.boolean()),
-  silent: import_mini51.z.optional(import_mini51.z.boolean())
+var FetchOptionsSchema = import_mini52.z.looseObject({
+  target: import_mini52.z.optional(FetchTargetSchema),
+  features: import_mini52.z.optional(import_mini52.z.array(import_mini52.z.enum(ALL_FEATURES_WITH_WILDCARD))),
+  ref: import_mini52.z.optional(import_mini52.z.string()),
+  path: import_mini52.z.optional(import_mini52.z.string()),
+  output: import_mini52.z.optional(import_mini52.z.string()),
+  conflict: import_mini52.z.optional(ConflictStrategySchema),
+  token: import_mini52.z.optional(import_mini52.z.string()),
+  verbose: import_mini52.z.optional(import_mini52.z.boolean()),
+  silent: import_mini52.z.optional(import_mini52.z.boolean())
 });
-var FetchFileStatusSchema = import_mini51.z.enum(["created", "overwritten", "skipped"]);
-var GitHubRepoInfoSchema = import_mini51.z.looseObject({
-  default_branch: import_mini51.z.string(),
-  private: import_mini51.z.boolean()
+var FetchFileStatusSchema = import_mini52.z.enum(["created", "overwritten", "skipped"]);
+var GitHubRepoInfoSchema = import_mini52.z.looseObject({
+  default_branch: import_mini52.z.string(),
+  private: import_mini52.z.boolean()
 });
-var GitHubReleaseAssetSchema = import_mini51.z.looseObject({
-  name: import_mini51.z.string(),
-  browser_download_url: import_mini51.z.string(),
-  size: import_mini51.z.number()
+var GitHubReleaseAssetSchema = import_mini52.z.looseObject({
+  name: import_mini52.z.string(),
+  browser_download_url: import_mini52.z.string(),
+  size: import_mini52.z.number()
 });
-var GitHubReleaseSchema = import_mini51.z.looseObject({
-  tag_name: import_mini51.z.string(),
-  name: import_mini51.z.nullable(import_mini51.z.string()),
-  prerelease: import_mini51.z.boolean(),
-  draft: import_mini51.z.boolean(),
-  assets: import_mini51.z.array(GitHubReleaseAssetSchema)
+var GitHubReleaseSchema = import_mini52.z.looseObject({
+  tag_name: import_mini52.z.string(),
+  name: import_mini52.z.nullable(import_mini52.z.string()),
+  prerelease: import_mini52.z.boolean(),
+  draft: import_mini52.z.boolean(),
+  assets: import_mini52.z.array(GitHubReleaseAssetSchema)
 });
 
 // src/lib/github-client.ts
@@ -13819,6 +13955,13 @@ var FEATURE_PATHS = {
 function isToolTarget(target) {
   return target !== "rulesync";
 }
+function validateFileSize(relativePath, size) {
+  if (size > MAX_FILE_SIZE) {
+    throw new GitHubClientError(
+      `File "${relativePath}" exceeds maximum size limit (${(size / 1024 / 1024).toFixed(2)}MB > ${MAX_FILE_SIZE / 1024 / 1024}MB)`
+    );
+  }
+}
 async function processFeatureConversion(params) {
   const { processor, outputDir } = params;
   const paths = [];
@@ -14083,11 +14226,7 @@ async function fetchFiles(params) {
       relativePath,
       intendedRootDir: outputBasePath
     });
-    if (size > MAX_FILE_SIZE) {
-      throw new GitHubClientError(
-        `File "${relativePath}" exceeds maximum size limit (${(size / 1024 / 1024).toFixed(2)}MB > ${MAX_FILE_SIZE / 1024 / 1024}MB)`
-      );
-    }
+    validateFileSize(relativePath, size);
   }
   const results = await Promise.all(
     filesToFetch.map(async ({ remotePath, relativePath }) => {
@@ -14119,6 +14258,15 @@ async function fetchFiles(params) {
 }
 async function collectFeatureFiles(params) {
   const { client, owner, repo, basePath, ref, enabledFeatures, semaphore } = params;
+  const dirCache = /* @__PURE__ */ new Map();
+  async function getCachedDirectory(path4) {
+    let promise = dirCache.get(path4);
+    if (promise === void 0) {
+      promise = withSemaphore(semaphore, () => client.listDirectory(owner, repo, path4, ref));
+      dirCache.set(path4, promise);
+    }
+    return promise;
+  }
   const tasks = enabledFeatures.flatMap(
     (feature) => FEATURE_PATHS[feature].map((featurePath) => ({ feature, featurePath }))
   );
@@ -14129,14 +14277,8 @@ async function collectFeatureFiles(params) {
       try {
         if (featurePath.includes(".")) {
           try {
-            const entries = await withSemaphore(
-              semaphore,
-              () => client.listDirectory(
-                owner,
-                repo,
-                basePath === "." || basePath === "" ? "." : basePath,
-                ref
-              )
+            const entries = await getCachedDirectory(
+              basePath === "." || basePath === "" ? "." : basePath
             );
             const fileEntry = entries.find((e) => e.name === featurePath && e.type === "file");
             if (fileEntry) {
@@ -14255,11 +14397,7 @@ async function fetchAndConvertToolFiles(params) {
       };
     }
     for (const { relativePath, size } of filesToFetch) {
-      if (size > MAX_FILE_SIZE) {
-        throw new GitHubClientError(
-          `File "${relativePath}" exceeds maximum size limit (${(size / 1024 / 1024).toFixed(2)}MB > ${MAX_FILE_SIZE / 1024 / 1024}MB)`
-        );
-      }
+      validateFileSize(relativePath, size);
     }
     const toolPaths = getToolPathMapping(target);
     await Promise.all(
@@ -14276,7 +14414,6 @@ async function fetchAndConvertToolFiles(params) {
         );
         await writeFileContent(localPath, content);
         logger.debug(`Fetched to temp: ${toolRelativePath}`);
-        return toolRelativePath;
       })
     );
     const outputBasePath = (0, import_node_path107.join)(baseDir, outputDir);
@@ -14429,29 +14566,29 @@ var import_jsonc_parser = require("jsonc-parser");
 var import_node_path108 = require("path");
 
 // src/config/config.ts
-var import_mini52 = require("zod/mini");
-var ConfigParamsSchema = import_mini52.z.object({
-  baseDirs: import_mini52.z.array(import_mini52.z.string()),
+var import_mini53 = require("zod/mini");
+var ConfigParamsSchema = import_mini53.z.object({
+  baseDirs: import_mini53.z.array(import_mini53.z.string()),
   targets: RulesyncTargetsSchema,
   features: RulesyncFeaturesSchema,
-  verbose: import_mini52.z.boolean(),
-  delete: import_mini52.z.boolean(),
+  verbose: import_mini53.z.boolean(),
+  delete: import_mini53.z.boolean(),
   // New non-experimental options
-  global: (0, import_mini52.optional)(import_mini52.z.boolean()),
-  silent: (0, import_mini52.optional)(import_mini52.z.boolean()),
-  simulateCommands: (0, import_mini52.optional)(import_mini52.z.boolean()),
-  simulateSubagents: (0, import_mini52.optional)(import_mini52.z.boolean()),
-  simulateSkills: (0, import_mini52.optional)(import_mini52.z.boolean()),
-  modularMcp: (0, import_mini52.optional)(import_mini52.z.boolean()),
-  dryRun: (0, import_mini52.optional)(import_mini52.z.boolean()),
-  check: (0, import_mini52.optional)(import_mini52.z.boolean())
+  global: (0, import_mini53.optional)(import_mini53.z.boolean()),
+  silent: (0, import_mini53.optional)(import_mini53.z.boolean()),
+  simulateCommands: (0, import_mini53.optional)(import_mini53.z.boolean()),
+  simulateSubagents: (0, import_mini53.optional)(import_mini53.z.boolean()),
+  simulateSkills: (0, import_mini53.optional)(import_mini53.z.boolean()),
+  modularMcp: (0, import_mini53.optional)(import_mini53.z.boolean()),
+  dryRun: (0, import_mini53.optional)(import_mini53.z.boolean()),
+  check: (0, import_mini53.optional)(import_mini53.z.boolean())
 });
-var PartialConfigParamsSchema = import_mini52.z.partial(ConfigParamsSchema);
-var ConfigFileSchema = import_mini52.z.object({
-  $schema: (0, import_mini52.optional)(import_mini52.z.string()),
-  ...import_mini52.z.partial(ConfigParamsSchema).shape
+var PartialConfigParamsSchema = import_mini53.z.partial(ConfigParamsSchema);
+var ConfigFileSchema = import_mini53.z.object({
+  $schema: (0, import_mini53.optional)(import_mini53.z.string()),
+  ...import_mini53.z.partial(ConfigParamsSchema).shape
 });
-var RequiredConfigParamsSchema = import_mini52.z.required(ConfigParamsSchema);
+var RequiredConfigParamsSchema = import_mini53.z.required(ConfigParamsSchema);
 var CONFLICTING_TARGET_PAIRS = [
   ["augmentcode", "augmentcode-legacy"],
   ["claudecode", "claudecode-legacy"]
@@ -14524,12 +14661,45 @@ var Config = class {
     }
     return this.targets.filter((target) => target !== "*");
   }
-  getFeatures() {
+  getFeatures(target) {
+    if (!Array.isArray(this.features)) {
+      const perTargetFeatures = this.features;
+      if (target) {
+        const targetFeatures = perTargetFeatures[target];
+        if (!targetFeatures || targetFeatures.length === 0) {
+          return [];
+        }
+        if (targetFeatures.includes("*")) {
+          return [...ALL_FEATURES];
+        }
+        return targetFeatures.filter((feature) => feature !== "*");
+      }
+      const allFeatures = [];
+      for (const features of Object.values(perTargetFeatures)) {
+        if (features && features.length > 0) {
+          if (features.includes("*")) {
+            return [...ALL_FEATURES];
+          }
+          for (const feature of features) {
+            if (feature !== "*" && !allFeatures.includes(feature)) {
+              allFeatures.push(feature);
+            }
+          }
+        }
+      }
+      return allFeatures;
+    }
     if (this.features.includes("*")) {
       return [...ALL_FEATURES];
     }
     return this.features.filter((feature) => feature !== "*");
   }
+  /**
+   * Check if per-target features configuration is being used.
+   */
+  hasPerTargetFeatures() {
+    return !Array.isArray(this.features);
+  }
   getVerbose() {
     return this.verbose;
   }
@@ -14710,9 +14880,6 @@ async function generate(params) {
 }
 async function generateRulesCore(params) {
   const { config, skills } = params;
-  if (!config.getFeatures().includes("rules")) {
-    return { count: 0, hasDiff: false };
-  }
   let totalCount = 0;
   let hasDiff = false;
   const isPreviewMode = config.isPreviewMode();
@@ -14722,6 +14889,9 @@ async function generateRulesCore(params) {
   );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
+      if (!config.getFeatures(toolTarget).includes("rules")) {
+        continue;
+      }
       const processor = new RulesProcessor({
         baseDir,
         toolTarget,
@@ -14748,9 +14918,6 @@ async function generateRulesCore(params) {
 }
 async function generateIgnoreCore(params) {
   const { config } = params;
-  if (!config.getFeatures().includes("ignore")) {
-    return { count: 0, hasDiff: false };
-  }
   if (config.getGlobal()) {
     return { count: 0, hasDiff: false };
   }
@@ -14758,6 +14925,9 @@ async function generateIgnoreCore(params) {
   let hasDiff = false;
   const isPreviewMode = config.isPreviewMode();
   for (const toolTarget of (0, import_es_toolkit4.intersection)(config.getTargets(), IgnoreProcessor.getToolTargets())) {
+    if (!config.getFeatures(toolTarget).includes("ignore")) {
+      continue;
+    }
     for (const baseDir of config.getBaseDirs()) {
       try {
         const processor = new IgnoreProcessor({
@@ -14793,9 +14963,6 @@ async function generateIgnoreCore(params) {
 }
 async function generateMcpCore(params) {
   const { config } = params;
-  if (!config.getFeatures().includes("mcp")) {
-    return { count: 0, hasDiff: false };
-  }
   let totalCount = 0;
   let hasDiff = false;
   const isPreviewMode = config.isPreviewMode();
@@ -14805,6 +14972,9 @@ async function generateMcpCore(params) {
   );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
+      if (!config.getFeatures(toolTarget).includes("mcp")) {
+        continue;
+      }
       const processor = new McpProcessor({
         baseDir,
         toolTarget,
@@ -14828,9 +14998,6 @@ async function generateMcpCore(params) {
 }
 async function generateCommandsCore(params) {
   const { config } = params;
-  if (!config.getFeatures().includes("commands")) {
-    return { count: 0, hasDiff: false };
-  }
   let totalCount = 0;
   let hasDiff = false;
   const isPreviewMode = config.isPreviewMode();
@@ -14843,6 +15010,9 @@ async function generateCommandsCore(params) {
   );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
+      if (!config.getFeatures(toolTarget).includes("commands")) {
+        continue;
+      }
       const processor = new CommandsProcessor({
         baseDir,
         toolTarget,
@@ -14865,9 +15035,6 @@ async function generateCommandsCore(params) {
 }
 async function generateSubagentsCore(params) {
   const { config } = params;
-  if (!config.getFeatures().includes("subagents")) {
-    return { count: 0, hasDiff: false };
-  }
   let totalCount = 0;
   let hasDiff = false;
   const isPreviewMode = config.isPreviewMode();
@@ -14880,6 +15047,9 @@ async function generateSubagentsCore(params) {
   );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
+      if (!config.getFeatures(toolTarget).includes("subagents")) {
+        continue;
+      }
       const processor = new SubagentsProcessor({
         baseDir,
         toolTarget,
@@ -14902,9 +15072,6 @@ async function generateSubagentsCore(params) {
 }
 async function generateSkillsCore(params) {
   const { config } = params;
-  if (!config.getFeatures().includes("skills")) {
-    return { count: 0, skills: [], hasDiff: false };
-  }
   let totalCount = 0;
   let hasDiff = false;
   const allSkills = [];
@@ -14918,6 +15085,9 @@ async function generateSkillsCore(params) {
   );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
+      if (!config.getFeatures(toolTarget).includes("skills")) {
+        continue;
+      }
       const processor = new SkillsProcessor({
         baseDir,
         toolTarget,
@@ -14945,9 +15115,6 @@ async function generateSkillsCore(params) {
 }
 async function generateHooksCore(params) {
   const { config } = params;
-  if (!config.getFeatures().includes("hooks")) {
-    return { count: 0, hasDiff: false };
-  }
   let totalCount = 0;
   let hasDiff = false;
   const isPreviewMode = config.isPreviewMode();
@@ -14957,6 +15124,9 @@ async function generateHooksCore(params) {
   );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
+      if (!config.getFeatures(toolTarget).includes("hooks")) {
+        continue;
+      }
       const processor = new HooksProcessor({
         baseDir,
         toolTarget,
@@ -14996,9 +15166,9 @@ function logFeatureResult(params) {
   const { count, featureName, isPreview, modePrefix } = params;
   if (count > 0) {
     if (isPreview) {
-      logger.info(`${modePrefix} Would generate ${count} ${featureName}`);
+      logger.info(`${modePrefix} Would write ${count} ${featureName}`);
     } else {
-      logger.success(`Generated ${count} ${featureName}`);
+      logger.success(`Written ${count} ${featureName}`);
     }
   }
 }
@@ -15093,7 +15263,7 @@ async function generateCommand(options) {
   const totalGenerated = calculateTotalCount(result);
   if (totalGenerated === 0) {
     const enabledFeatures = features.join(", ");
-    logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
+    logger.info(`\u2713 All files are up to date (${enabledFeatures})`);
     return;
   }
   const parts = [];
@@ -15105,11 +15275,9 @@ async function generateCommand(options) {
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
   if (isPreview) {
-    logger.info(
-      `${modePrefix} Would generate ${totalGenerated} file(s) total (${parts.join(" + ")})`
-    );
+    logger.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   } else {
-    logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
+    logger.success(`\u{1F389} All done! Written ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
   if (check) {
     if (result.hasDiff) {
@@ -15319,7 +15487,7 @@ async function importFromTool(params) {
 }
 async function importRulesCore(params) {
   const { config, tool } = params;
-  if (!config.getFeatures().includes("rules")) {
+  if (!config.getFeatures(tool).includes("rules")) {
     return 0;
   }
   const global = config.getGlobal();
@@ -15345,7 +15513,7 @@ async function importRulesCore(params) {
 }
 async function importIgnoreCore(params) {
   const { config, tool } = params;
-  if (!config.getFeatures().includes("ignore")) {
+  if (!config.getFeatures(tool).includes("ignore")) {
     return 0;
   }
   if (config.getGlobal()) {
@@ -15375,7 +15543,7 @@ async function importIgnoreCore(params) {
 }
 async function importMcpCore(params) {
   const { config, tool } = params;
-  if (!config.getFeatures().includes("mcp")) {
+  if (!config.getFeatures(tool).includes("mcp")) {
     return 0;
   }
   const global = config.getGlobal();
@@ -15401,7 +15569,7 @@ async function importMcpCore(params) {
 }
 async function importCommandsCore(params) {
   const { config, tool } = params;
-  if (!config.getFeatures().includes("commands")) {
+  if (!config.getFeatures(tool).includes("commands")) {
     return 0;
   }
   const global = config.getGlobal();
@@ -15427,7 +15595,7 @@ async function importCommandsCore(params) {
 }
 async function importSubagentsCore(params) {
   const { config, tool } = params;
-  if (!config.getFeatures().includes("subagents")) {
+  if (!config.getFeatures(tool).includes("subagents")) {
     return 0;
   }
   const global = config.getGlobal();
@@ -15453,7 +15621,7 @@ async function importSubagentsCore(params) {
 }
 async function importSkillsCore(params) {
   const { config, tool } = params;
-  if (!config.getFeatures().includes("skills")) {
+  if (!config.getFeatures(tool).includes("skills")) {
     return 0;
   }
   const global = config.getGlobal();
@@ -15479,7 +15647,7 @@ async function importSkillsCore(params) {
 }
 async function importHooksCore(params) {
   const { config, tool } = params;
-  if (!config.getFeatures().includes("hooks")) {
+  if (!config.getFeatures(tool).includes("hooks")) {
     return 0;
   }
   const global = config.getGlobal();
@@ -15792,11 +15960,11 @@ async function initCommand() {
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini61 = require("zod/mini");
+var import_mini62 = require("zod/mini");
 
 // src/mcp/commands.ts
 var import_node_path112 = require("path");
-var import_mini53 = require("zod/mini");
+var import_mini54 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -15915,17 +16083,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini53.z.object({}),
-  getCommand: import_mini53.z.object({
-    relativePathFromCwd: import_mini53.z.string()
+  listCommands: import_mini54.z.object({}),
+  getCommand: import_mini54.z.object({
+    relativePathFromCwd: import_mini54.z.string()
   }),
-  putCommand: import_mini53.z.object({
-    relativePathFromCwd: import_mini53.z.string(),
+  putCommand: import_mini54.z.object({
+    relativePathFromCwd: import_mini54.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini53.z.string()
+    body: import_mini54.z.string()
   }),
-  deleteCommand: import_mini53.z.object({
-    relativePathFromCwd: import_mini53.z.string()
+  deleteCommand: import_mini54.z.object({
+    relativePathFromCwd: import_mini54.z.string()
   })
 };
 var commandTools = {
@@ -15973,16 +16141,16 @@ var commandTools = {
 };
 
 // src/mcp/generate.ts
-var import_mini54 = require("zod/mini");
-var generateOptionsSchema = import_mini54.z.object({
-  targets: import_mini54.z.optional(import_mini54.z.array(import_mini54.z.string())),
-  features: import_mini54.z.optional(import_mini54.z.array(import_mini54.z.string())),
-  delete: import_mini54.z.optional(import_mini54.z.boolean()),
-  global: import_mini54.z.optional(import_mini54.z.boolean()),
-  simulateCommands: import_mini54.z.optional(import_mini54.z.boolean()),
-  simulateSubagents: import_mini54.z.optional(import_mini54.z.boolean()),
-  simulateSkills: import_mini54.z.optional(import_mini54.z.boolean()),
-  modularMcp: import_mini54.z.optional(import_mini54.z.boolean())
+var import_mini55 = require("zod/mini");
+var generateOptionsSchema = import_mini55.z.object({
+  targets: import_mini55.z.optional(import_mini55.z.array(import_mini55.z.string())),
+  features: import_mini55.z.optional(import_mini55.z.array(import_mini55.z.string())),
+  delete: import_mini55.z.optional(import_mini55.z.boolean()),
+  global: import_mini55.z.optional(import_mini55.z.boolean()),
+  simulateCommands: import_mini55.z.optional(import_mini55.z.boolean()),
+  simulateSubagents: import_mini55.z.optional(import_mini55.z.boolean()),
+  simulateSkills: import_mini55.z.optional(import_mini55.z.boolean()),
+  modularMcp: import_mini55.z.optional(import_mini55.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -16062,7 +16230,7 @@ var generateTools = {
 
 // src/mcp/ignore.ts
 var import_node_path113 = require("path");
-var import_mini55 = require("zod/mini");
+var import_mini56 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path113.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -16119,11 +16287,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini55.z.object({}),
-  putIgnoreFile: import_mini55.z.object({
-    content: import_mini55.z.string()
+  getIgnoreFile: import_mini56.z.object({}),
+  putIgnoreFile: import_mini56.z.object({
+    content: import_mini56.z.string()
   }),
-  deleteIgnoreFile: import_mini55.z.object({})
+  deleteIgnoreFile: import_mini56.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -16156,11 +16324,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-var import_mini56 = require("zod/mini");
-var importOptionsSchema = import_mini56.z.object({
-  target: import_mini56.z.string(),
-  features: import_mini56.z.optional(import_mini56.z.array(import_mini56.z.string())),
-  global: import_mini56.z.optional(import_mini56.z.boolean())
+var import_mini57 = require("zod/mini");
+var importOptionsSchema = import_mini57.z.object({
+  target: import_mini57.z.string(),
+  features: import_mini57.z.optional(import_mini57.z.array(import_mini57.z.string())),
+  global: import_mini57.z.optional(import_mini57.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -16230,7 +16398,7 @@ var importTools = {
 
 // src/mcp/mcp.ts
 var import_node_path114 = require("path");
-var import_mini57 = require("zod/mini");
+var import_mini58 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -16320,11 +16488,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini57.z.object({}),
-  putMcpFile: import_mini57.z.object({
-    content: import_mini57.z.string()
+  getMcpFile: import_mini58.z.object({}),
+  putMcpFile: import_mini58.z.object({
+    content: import_mini58.z.string()
   }),
-  deleteMcpFile: import_mini57.z.object({})
+  deleteMcpFile: import_mini58.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -16358,7 +16526,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 var import_node_path115 = require("path");
-var import_mini58 = require("zod/mini");
+var import_mini59 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -16477,17 +16645,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini58.z.object({}),
-  getRule: import_mini58.z.object({
-    relativePathFromCwd: import_mini58.z.string()
+  listRules: import_mini59.z.object({}),
+  getRule: import_mini59.z.object({
+    relativePathFromCwd: import_mini59.z.string()
   }),
-  putRule: import_mini58.z.object({
-    relativePathFromCwd: import_mini58.z.string(),
+  putRule: import_mini59.z.object({
+    relativePathFromCwd: import_mini59.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini58.z.string()
+    body: import_mini59.z.string()
   }),
-  deleteRule: import_mini58.z.object({
-    relativePathFromCwd: import_mini58.z.string()
+  deleteRule: import_mini59.z.object({
+    relativePathFromCwd: import_mini59.z.string()
   })
 };
 var ruleTools = {
@@ -16536,7 +16704,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path116 = require("path");
-var import_mini59 = require("zod/mini");
+var import_mini60 = require("zod/mini");
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -16704,23 +16872,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini59.z.object({
-  name: import_mini59.z.string(),
-  body: import_mini59.z.string()
+var McpSkillFileSchema = import_mini60.z.object({
+  name: import_mini60.z.string(),
+  body: import_mini60.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini59.z.object({}),
-  getSkill: import_mini59.z.object({
-    relativeDirPathFromCwd: import_mini59.z.string()
+  listSkills: import_mini60.z.object({}),
+  getSkill: import_mini60.z.object({
+    relativeDirPathFromCwd: import_mini60.z.string()
   }),
-  putSkill: import_mini59.z.object({
-    relativeDirPathFromCwd: import_mini59.z.string(),
+  putSkill: import_mini60.z.object({
+    relativeDirPathFromCwd: import_mini60.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini59.z.string(),
-    otherFiles: import_mini59.z.optional(import_mini59.z.array(McpSkillFileSchema))
+    body: import_mini60.z.string(),
+    otherFiles: import_mini60.z.optional(import_mini60.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini59.z.object({
-    relativeDirPathFromCwd: import_mini59.z.string()
+  deleteSkill: import_mini60.z.object({
+    relativeDirPathFromCwd: import_mini60.z.string()
   })
 };
 var skillTools = {
@@ -16770,7 +16938,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path117 = require("path");
-var import_mini60 = require("zod/mini");
+var import_mini61 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -16894,17 +17062,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini60.z.object({}),
-  getSubagent: import_mini60.z.object({
-    relativePathFromCwd: import_mini60.z.string()
+  listSubagents: import_mini61.z.object({}),
+  getSubagent: import_mini61.z.object({
+    relativePathFromCwd: import_mini61.z.string()
   }),
-  putSubagent: import_mini60.z.object({
-    relativePathFromCwd: import_mini60.z.string(),
+  putSubagent: import_mini61.z.object({
+    relativePathFromCwd: import_mini61.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini60.z.string()
+    body: import_mini61.z.string()
   }),
-  deleteSubagent: import_mini60.z.object({
-    relativePathFromCwd: import_mini60.z.string()
+  deleteSubagent: import_mini61.z.object({
+    relativePathFromCwd: import_mini61.z.string()
   })
 };
 var subagentTools = {
@@ -16952,7 +17120,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini61.z.enum([
+var rulesyncFeatureSchema = import_mini62.z.enum([
   "rule",
   "command",
   "subagent",
@@ -16962,21 +17130,21 @@ var rulesyncFeatureSchema = import_mini61.z.enum([
   "generate",
   "import"
 ]);
-var rulesyncOperationSchema = import_mini61.z.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = import_mini61.z.object({
-  name: import_mini61.z.string(),
-  body: import_mini61.z.string()
+var rulesyncOperationSchema = import_mini62.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini62.z.object({
+  name: import_mini62.z.string(),
+  body: import_mini62.z.string()
 });
-var rulesyncToolSchema = import_mini61.z.object({
+var rulesyncToolSchema = import_mini62.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini61.z.optional(import_mini61.z.string()),
-  frontmatter: import_mini61.z.optional(import_mini61.z.unknown()),
-  body: import_mini61.z.optional(import_mini61.z.string()),
-  otherFiles: import_mini61.z.optional(import_mini61.z.array(skillFileSchema)),
-  content: import_mini61.z.optional(import_mini61.z.string()),
-  generateOptions: import_mini61.z.optional(generateOptionsSchema),
-  importOptions: import_mini61.z.optional(importOptionsSchema)
+  targetPathFromCwd: import_mini62.z.optional(import_mini62.z.string()),
+  frontmatter: import_mini62.z.optional(import_mini62.z.unknown()),
+  body: import_mini62.z.optional(import_mini62.z.string()),
+  otherFiles: import_mini62.z.optional(import_mini62.z.array(skillFileSchema)),
+  content: import_mini62.z.optional(import_mini62.z.string()),
+  generateOptions: import_mini62.z.optional(generateOptionsSchema),
+  importOptions: import_mini62.z.optional(importOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -17535,7 +17703,7 @@ async function updateCommand(currentVersion, options) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "6.7.0";
+var getVersion = () => "6.8.1";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();