rulesync 6.7.0 → 6.8.1

package/dist/index.js

@@ -20,7 +20,10 @@ var ALL_FEATURES = [
 var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 var FeatureSchema = z.enum(ALL_FEATURES);
 var FeaturesSchema = z.array(FeatureSchema);
-var RulesyncFeaturesSchema = z.array(z.enum(ALL_FEATURES_WITH_WILDCARD));
+var RulesyncFeaturesSchema = z.union([
+  z.array(z.enum(ALL_FEATURES_WITH_WILDCARD)),
+  z.record(z.string(), z.array(z.enum(ALL_FEATURES_WITH_WILDCARD)))
+]);
 
 // src/utils/error.ts
 import { ZodError } from "zod";
@@ -5429,7 +5432,7 @@ var OpencodeMcp = class _OpencodeMcp extends ToolMcp {
   static getSettablePaths({ global } = {}) {
     if (global) {
       return {
-        relativeDirPath: ".",
+        relativeDirPath: join47(".config", "opencode"),
         relativeFilePath: "opencode.json"
       };
     }
@@ -5889,7 +5892,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 import { encode } from "@toon-format/toon";
 import { basename as basename23, join as join105, relative as relative4 } from "path";
-import { z as z48 } from "zod/mini";
+import { z as z49 } from "zod/mini";
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -6350,46 +6353,12 @@ var FactorydroidSkill = class _FactorydroidSkill extends SimulatedSkill {
   }
 };
 
-// src/features/skills/geminicli-skill.ts
-import { join as join54 } from "path";
-var GeminiCliSkill = class _GeminiCliSkill extends SimulatedSkill {
-  static getSettablePaths(options) {
-    if (options?.global) {
-      throw new Error("GeminiCliSkill does not support global mode.");
-    }
-    return {
-      relativeDirPath: join54(".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
 import { basename as basename18, join as join68 } from "path";
-import { z as z33 } from "zod/mini";
+import { z as z34 } from "zod/mini";
 
 // src/types/dir-feature-processor.ts
-import { join as join55 } from "path";
+import { join as join54 } from "path";
 var DirFeatureProcessor = class {
   baseDir;
   dryRun;
@@ -6406,6 +6375,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;
@@ -6415,7 +6388,7 @@ var DirFeatureProcessor = class {
       const mainFile = aiDir.getMainFile();
       let mainFileContent;
       if (mainFile) {
-        const mainFilePath = join55(dirPath, mainFile.name);
+        const mainFilePath = join54(dirPath, mainFile.name);
         const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
         mainFileContent = addTrailingNewline(content);
         const existingContent = await readFileContentOrNull(mainFilePath);
@@ -6429,7 +6402,7 @@ var DirFeatureProcessor = class {
         const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
         otherFileContents.push(contentWithNewline);
         if (!dirHasChanges) {
-          const filePath = join55(dirPath, file.relativeFilePathToDirPath);
+          const filePath = join54(dirPath, file.relativeFilePathToDirPath);
           const existingContent = await readFileContentOrNull(filePath);
           if (existingContent !== contentWithNewline) {
             dirHasChanges = true;
@@ -6442,20 +6415,25 @@ var DirFeatureProcessor = class {
       if (this.dryRun) {
         logger.info(`[DRY RUN] Would create directory: ${dirPath}`);
         if (mainFile) {
-          logger.info(`[DRY RUN] Would write: ${join55(dirPath, mainFile.name)}`);
+          logger.info(`[DRY RUN] Would write: ${join54(dirPath, mainFile.name)}`);
         }
         for (const file of otherFiles) {
-          logger.info(`[DRY RUN] Would write: ${join55(dirPath, file.relativeFilePathToDirPath)}`);
+          logger.info(`[DRY RUN] Would write: ${join54(dirPath, file.relativeFilePathToDirPath)}`);
         }
       } else {
         await ensureDir(dirPath);
         if (mainFile && mainFileContent) {
-          const mainFilePath = join55(dirPath, mainFile.name);
+          const mainFilePath = join54(dirPath, mainFile.name);
           await writeFileContent(mainFilePath, mainFileContent);
         }
         for (const [i, file] of otherFiles.entries()) {
-          const filePath = join55(dirPath, file.relativeFilePathToDirPath);
-          const content = otherFileContents[i] ?? "";
+          const filePath = join54(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);
         }
       }
@@ -6488,11 +6466,11 @@ var DirFeatureProcessor = class {
 };
 
 // src/features/skills/agentsskills-skill.ts
-import { join as join57 } from "path";
+import { join as join56 } from "path";
 import { z as z22 } from "zod/mini";
 
 // src/features/skills/rulesync-skill.ts
-import { join as join56 } from "path";
+import { join as join55 } from "path";
 import { z as z21 } from "zod/mini";
 var RulesyncSkillFrontmatterSchemaInternal = z21.looseObject({
   name: z21.string(),
@@ -6584,8 +6562,8 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
     dirName,
     global = false
   }) {
-    const skillDirPath = join56(baseDir, relativeDirPath, dirName);
-    const skillFilePath = join56(skillDirPath, SKILL_FILE_NAME);
+    const skillDirPath = join55(baseDir, relativeDirPath, dirName);
+    const skillFilePath = join55(skillDirPath, SKILL_FILE_NAME);
     if (!await fileExists(skillFilePath)) {
       throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
     }
@@ -6622,7 +6600,7 @@ var AgentsSkillsSkillFrontmatterSchema = z22.looseObject({
 var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = join57(".agents", "skills"),
+    relativeDirPath = join56(".agents", "skills"),
     dirName,
     frontmatter,
     body,
@@ -6654,7 +6632,7 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
       throw new Error("AgentsSkillsSkill does not support global mode.");
     }
     return {
-      relativeDirPath: join57(".agents", "skills")
+      relativeDirPath: join56(".agents", "skills")
     };
   }
   getFrontmatter() {
@@ -6736,9 +6714,9 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
     });
     const result = AgentsSkillsSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = join57(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = join56(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${join57(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join56(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _AgentsSkillsSkill({
@@ -6773,7 +6751,7 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
 };
 
 // src/features/skills/antigravity-skill.ts
-import { join as join58 } from "path";
+import { join as join57 } from "path";
 import { z as z23 } from "zod/mini";
 var AntigravitySkillFrontmatterSchema = z23.looseObject({
   name: z23.string(),
@@ -6782,7 +6760,7 @@ var AntigravitySkillFrontmatterSchema = z23.looseObject({
 var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = join58(".agent", "skills"),
+    relativeDirPath = join57(".agent", "skills"),
     dirName,
     frontmatter,
     body,
@@ -6814,11 +6792,11 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
   } = {}) {
     if (global) {
       return {
-        relativeDirPath: join58(".gemini", "antigravity", "skills")
+        relativeDirPath: join57(".gemini", "antigravity", "skills")
       };
     }
     return {
-      relativeDirPath: join58(".agent", "skills")
+      relativeDirPath: join57(".agent", "skills")
     };
   }
   getFrontmatter() {
@@ -6900,9 +6878,9 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
     });
     const result = AntigravitySkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = join58(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = join57(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${join58(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join57(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _AntigravitySkill({
@@ -6936,7 +6914,7 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
 };
 
 // src/features/skills/claudecode-skill.ts
-import { join as join59 } from "path";
+import { join as join58 } from "path";
 import { z as z24 } from "zod/mini";
 var ClaudecodeSkillFrontmatterSchema = z24.looseObject({
   name: z24.string(),
@@ -6946,7 +6924,7 @@ var ClaudecodeSkillFrontmatterSchema = z24.looseObject({
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = join59(".claude", "skills"),
+    relativeDirPath = join58(".claude", "skills"),
     dirName,
     frontmatter,
     body,
@@ -6977,7 +6955,7 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
     global: _global = false
   } = {}) {
     return {
-      relativeDirPath: join59(".claude", "skills")
+      relativeDirPath: join58(".claude", "skills")
     };
   }
   getFrontmatter() {
@@ -7065,9 +7043,9 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
     });
     const result = ClaudecodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = join59(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = join58(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${join59(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join58(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _ClaudecodeSkill({
@@ -7101,7 +7079,7 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
 };
 
 // src/features/skills/codexcli-skill.ts
-import { join as join60 } from "path";
+import { join as join59 } from "path";
 import { z as z25 } from "zod/mini";
 var CodexCliSkillFrontmatterSchema = z25.looseObject({
   name: z25.string(),
@@ -7115,7 +7093,7 @@ var CodexCliSkillFrontmatterSchema = z25.looseObject({
 var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = join60(".codex", "skills"),
+    relativeDirPath = join59(".codex", "skills"),
     dirName,
     frontmatter,
     body,
@@ -7146,7 +7124,7 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
     global: _global = false
   } = {}) {
     return {
-      relativeDirPath: join60(".codex", "skills")
+      relativeDirPath: join59(".codex", "skills")
     };
   }
   getFrontmatter() {
@@ -7238,9 +7216,9 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
     });
     const result = CodexCliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = join60(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = join59(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${join60(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join59(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _CodexCliSkill({
@@ -7274,7 +7252,7 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
 };
 
 // src/features/skills/copilot-skill.ts
-import { join as join61 } from "path";
+import { join as join60 } from "path";
 import { z as z26 } from "zod/mini";
 var CopilotSkillFrontmatterSchema = z26.looseObject({
   name: z26.string(),
@@ -7284,7 +7262,7 @@ var CopilotSkillFrontmatterSchema = z26.looseObject({
 var CopilotSkill = class _CopilotSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = join61(".github", "skills"),
+    relativeDirPath = join60(".github", "skills"),
     dirName,
     frontmatter,
     body,
@@ -7316,7 +7294,7 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
       throw new Error("CopilotSkill does not support global mode.");
     }
     return {
-      relativeDirPath: join61(".github", "skills")
+      relativeDirPath: join60(".github", "skills")
     };
   }
   getFrontmatter() {
@@ -7404,9 +7382,9 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
     });
     const result = CopilotSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = join61(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = join60(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${join61(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join60(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _CopilotSkill({
@@ -7441,7 +7419,7 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
 };
 
 // src/features/skills/cursor-skill.ts
-import { join as join62 } from "path";
+import { join as join61 } from "path";
 import { z as z27 } from "zod/mini";
 var CursorSkillFrontmatterSchema = z27.looseObject({
   name: z27.string(),
@@ -7450,7 +7428,7 @@ var CursorSkillFrontmatterSchema = z27.looseObject({
 var CursorSkill = class _CursorSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = join62(".cursor", "skills"),
+    relativeDirPath = join61(".cursor", "skills"),
     dirName,
     frontmatter,
     body,
@@ -7479,7 +7457,7 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
   }
   static getSettablePaths(_options) {
     return {
-      relativeDirPath: join62(".cursor", "skills")
+      relativeDirPath: join61(".cursor", "skills")
     };
   }
   getFrontmatter() {
@@ -7561,9 +7539,9 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
     });
     const result = CursorSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = join62(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = join61(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${join62(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join61(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _CursorSkill({
@@ -7597,13 +7575,172 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
   }
 };
 
-// src/features/skills/kilo-skill.ts
-import { join as join63 } from "path";
+// src/features/skills/geminicli-skill.ts
+import { join as join62 } from "path";
 import { z as z28 } from "zod/mini";
-var KiloSkillFrontmatterSchema = z28.looseObject({
+var GeminiCliSkillFrontmatterSchema = z28.looseObject({
   name: z28.string(),
   description: z28.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: join62(".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 = join62(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      throw new Error(
+        `Invalid frontmatter in ${join62(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
+import { join as join63 } from "path";
+import { z as z29 } from "zod/mini";
+var KiloSkillFrontmatterSchema = z29.looseObject({
+  name: z29.string(),
+  description: z29.string()
+});
 var KiloSkill = class _KiloSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
@@ -7776,10 +7913,10 @@ var KiloSkill = class _KiloSkill extends ToolSkill {
 
 // src/features/skills/kiro-skill.ts
 import { join as join64 } from "path";
-import { z as z29 } from "zod/mini";
-var KiroSkillFrontmatterSchema = z29.looseObject({
-  name: z29.string(),
-  description: z29.string()
+import { z as z30 } from "zod/mini";
+var KiroSkillFrontmatterSchema = z30.looseObject({
+  name: z30.string(),
+  description: z30.string()
 });
 var KiroSkill = class _KiroSkill extends ToolSkill {
   constructor({
@@ -7955,11 +8092,11 @@ var KiroSkill = class _KiroSkill extends ToolSkill {
 
 // src/features/skills/opencode-skill.ts
 import { join as join65 } from "path";
-import { z as z30 } from "zod/mini";
-var OpenCodeSkillFrontmatterSchema = z30.looseObject({
-  name: z30.string(),
-  description: z30.string(),
-  "allowed-tools": z30.optional(z30.array(z30.string()))
+import { z as z31 } from "zod/mini";
+var OpenCodeSkillFrontmatterSchema = z31.looseObject({
+  name: z31.string(),
+  description: z31.string(),
+  "allowed-tools": z31.optional(z31.array(z31.string()))
 });
 var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
   constructor({
@@ -8118,10 +8255,10 @@ var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
 
 // src/features/skills/replit-skill.ts
 import { join as join66 } from "path";
-import { z as z31 } from "zod/mini";
-var ReplitSkillFrontmatterSchema = z31.looseObject({
-  name: z31.string(),
-  description: z31.string()
+import { z as z32 } from "zod/mini";
+var ReplitSkillFrontmatterSchema = z32.looseObject({
+  name: z32.string(),
+  description: z32.string()
 });
 var ReplitSkill = class _ReplitSkill extends ToolSkill {
   constructor({
@@ -8278,10 +8415,10 @@ var ReplitSkill = class _ReplitSkill extends ToolSkill {
 
 // src/features/skills/roo-skill.ts
 import { join as join67 } from "path";
-import { z as z32 } from "zod/mini";
-var RooSkillFrontmatterSchema = z32.looseObject({
-  name: z32.string(),
-  description: z32.string()
+import { z as z33 } from "zod/mini";
+var RooSkillFrontmatterSchema = z33.looseObject({
+  name: z33.string(),
+  description: z33.string()
 });
 var RooSkill = class _RooSkill extends ToolSkill {
   constructor({
@@ -8471,7 +8608,7 @@ var skillsProcessorToolTargetTuple = [
   "replit",
   "roo"
 ];
-var SkillsProcessorToolTargetSchema = z33.enum(skillsProcessorToolTargetTuple);
+var SkillsProcessorToolTargetSchema = z34.enum(skillsProcessorToolTargetTuple);
 var toolSkillFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -8540,7 +8677,7 @@ var toolSkillFactories = /* @__PURE__ */ new Map([
     "geminicli",
     {
       class: GeminiCliSkill,
-      meta: { supportsProject: true, supportsSimulated: true, supportsGlobal: false }
+      meta: { supportsProject: true, supportsSimulated: false, supportsGlobal: true }
     }
   ],
   [
@@ -8760,7 +8897,7 @@ import { join as join70 } from "path";
 
 // src/features/subagents/simulated-subagent.ts
 import { basename as basename19, join as join69 } from "path";
-import { z as z34 } from "zod/mini";
+import { z as z35 } from "zod/mini";
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -8803,9 +8940,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z34.object({
-  name: z34.string(),
-  description: z34.string()
+var SimulatedSubagentFrontmatterSchema = z35.object({
+  name: z35.string(),
+  description: z35.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -9044,19 +9181,19 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 import { basename as basename22, join as join81 } from "path";
-import { z as z41 } from "zod/mini";
+import { z as z42 } from "zod/mini";
 
 // src/features/subagents/claudecode-subagent.ts
 import { join as join76 } from "path";
-import { z as z36 } from "zod/mini";
+import { z as z37 } from "zod/mini";
 
 // src/features/subagents/rulesync-subagent.ts
 import { basename as basename20, join as join75 } from "path";
-import { z as z35 } from "zod/mini";
-var RulesyncSubagentFrontmatterSchema = z35.looseObject({
-  targets: z35._default(RulesyncTargetsSchema, ["*"]),
-  name: z35.string(),
-  description: z35.string()
+import { z as z36 } from "zod/mini";
+var RulesyncSubagentFrontmatterSchema = z36.looseObject({
+  targets: z36._default(RulesyncTargetsSchema, ["*"]),
+  name: z36.string(),
+  description: z36.string()
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -9126,13 +9263,13 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z36.looseObject({
-  name: z36.string(),
-  description: z36.string(),
-  model: z36.optional(z36.string()),
-  tools: z36.optional(z36.union([z36.string(), z36.array(z36.string())])),
-  permissionMode: z36.optional(z36.string()),
-  skills: z36.optional(z36.union([z36.string(), z36.array(z36.string())]))
+var ClaudecodeSubagentFrontmatterSchema = z37.looseObject({
+  name: z37.string(),
+  description: z37.string(),
+  model: z37.optional(z37.string()),
+  tools: z37.optional(z37.union([z37.string(), z37.array(z37.string())])),
+  permissionMode: z37.optional(z37.string()),
+  skills: z37.optional(z37.union([z37.string(), z37.array(z37.string())]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -9282,12 +9419,12 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 
 // src/features/subagents/copilot-subagent.ts
 import { join as join77 } from "path";
-import { z as z37 } from "zod/mini";
+import { z as z38 } from "zod/mini";
 var REQUIRED_TOOL = "agent/runSubagent";
-var CopilotSubagentFrontmatterSchema = z37.looseObject({
-  name: z37.string(),
-  description: z37.string(),
-  tools: z37.optional(z37.union([z37.string(), z37.array(z37.string())]))
+var CopilotSubagentFrontmatterSchema = z38.looseObject({
+  name: z38.string(),
+  description: z38.string(),
+  tools: z38.optional(z38.union([z38.string(), z38.array(z38.string())]))
 });
 var normalizeTools = (tools) => {
   if (!tools) {
@@ -9448,10 +9585,10 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
 
 // src/features/subagents/cursor-subagent.ts
 import { join as join78 } from "path";
-import { z as z38 } from "zod/mini";
-var CursorSubagentFrontmatterSchema = z38.looseObject({
-  name: z38.string(),
-  description: z38.string()
+import { z as z39 } from "zod/mini";
+var CursorSubagentFrontmatterSchema = z39.looseObject({
+  name: z39.string(),
+  description: z39.string()
 });
 var CursorSubagent = class _CursorSubagent extends ToolSubagent {
   frontmatter;
@@ -9595,22 +9732,22 @@ var CursorSubagent = class _CursorSubagent extends ToolSubagent {
 
 // src/features/subagents/kiro-subagent.ts
 import { join as join79 } from "path";
-import { z as z39 } from "zod/mini";
-var KiroCliSubagentJsonSchema = z39.looseObject({
-  name: z39.string(),
-  description: z39.optional(z39.nullable(z39.string())),
-  prompt: z39.optional(z39.nullable(z39.string())),
-  tools: z39.optional(z39.nullable(z39.array(z39.string()))),
-  toolAliases: z39.optional(z39.nullable(z39.record(z39.string(), z39.string()))),
-  toolSettings: z39.optional(z39.nullable(z39.unknown())),
-  toolSchema: z39.optional(z39.nullable(z39.unknown())),
-  hooks: z39.optional(z39.nullable(z39.record(z39.string(), z39.array(z39.unknown())))),
-  model: z39.optional(z39.nullable(z39.string())),
-  mcpServers: z39.optional(z39.nullable(z39.record(z39.string(), z39.unknown()))),
-  useLegacyMcpJson: z39.optional(z39.nullable(z39.boolean())),
-  resources: z39.optional(z39.nullable(z39.array(z39.string()))),
-  allowedTools: z39.optional(z39.nullable(z39.array(z39.string()))),
-  includeMcpJson: z39.optional(z39.nullable(z39.boolean()))
+import { z as z40 } from "zod/mini";
+var KiroCliSubagentJsonSchema = z40.looseObject({
+  name: z40.string(),
+  description: z40.optional(z40.nullable(z40.string())),
+  prompt: z40.optional(z40.nullable(z40.string())),
+  tools: z40.optional(z40.nullable(z40.array(z40.string()))),
+  toolAliases: z40.optional(z40.nullable(z40.record(z40.string(), z40.string()))),
+  toolSettings: z40.optional(z40.nullable(z40.unknown())),
+  toolSchema: z40.optional(z40.nullable(z40.unknown())),
+  hooks: z40.optional(z40.nullable(z40.record(z40.string(), z40.array(z40.unknown())))),
+  model: z40.optional(z40.nullable(z40.string())),
+  mcpServers: z40.optional(z40.nullable(z40.record(z40.string(), z40.unknown()))),
+  useLegacyMcpJson: z40.optional(z40.nullable(z40.boolean())),
+  resources: z40.optional(z40.nullable(z40.array(z40.string()))),
+  allowedTools: z40.optional(z40.nullable(z40.array(z40.string()))),
+  includeMcpJson: z40.optional(z40.nullable(z40.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -9732,11 +9869,11 @@ var KiroSubagent = class _KiroSubagent extends ToolSubagent {
 
 // src/features/subagents/opencode-subagent.ts
 import { basename as basename21, join as join80 } from "path";
-import { z as z40 } from "zod/mini";
-var OpenCodeSubagentFrontmatterSchema = z40.looseObject({
-  description: z40.string(),
-  mode: z40.literal("subagent"),
-  name: z40.optional(z40.string())
+import { z as z41 } from "zod/mini";
+var OpenCodeSubagentFrontmatterSchema = z41.looseObject({
+  description: z41.string(),
+  mode: z41.literal("subagent"),
+  name: z41.optional(z41.string())
 });
 var OpenCodeSubagent = class _OpenCodeSubagent extends ToolSubagent {
   frontmatter;
@@ -9892,7 +10029,7 @@ var subagentsProcessorToolTargetTuple = [
   "opencode",
   "roo"
 ];
-var SubagentsProcessorToolTargetSchema = z41.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = z42.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -10169,42 +10306,42 @@ import { join as join83 } from "path";
 
 // src/features/rules/rulesync-rule.ts
 import { join as join82 } from "path";
-import { z as z42 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z42.object({
-  root: z42.optional(z42.boolean()),
-  localRoot: z42.optional(z42.boolean()),
-  targets: z42._default(RulesyncTargetsSchema, ["*"]),
-  description: z42.optional(z42.string()),
-  globs: z42.optional(z42.array(z42.string())),
-  agentsmd: z42.optional(
-    z42.object({
+import { z as z43 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z43.object({
+  root: z43.optional(z43.boolean()),
+  localRoot: z43.optional(z43.boolean()),
+  targets: z43._default(RulesyncTargetsSchema, ["*"]),
+  description: z43.optional(z43.string()),
+  globs: z43.optional(z43.array(z43.string())),
+  agentsmd: z43.optional(
+    z43.object({
       // @example "path/to/subproject"
-      subprojectPath: z42.optional(z42.string())
+      subprojectPath: z43.optional(z43.string())
     })
   ),
-  claudecode: z42.optional(
-    z42.object({
+  claudecode: z43.optional(
+    z43.object({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example ["src/**/*.ts", "tests/**/*.test.ts"]
-      paths: z42.optional(z42.array(z42.string()))
+      paths: z43.optional(z43.array(z43.string()))
     })
   ),
-  cursor: z42.optional(
-    z42.object({
-      alwaysApply: z42.optional(z42.boolean()),
-      description: z42.optional(z42.string()),
-      globs: z42.optional(z42.array(z42.string()))
+  cursor: z43.optional(
+    z43.object({
+      alwaysApply: z43.optional(z43.boolean()),
+      description: z43.optional(z43.string()),
+      globs: z43.optional(z43.array(z43.string()))
     })
   ),
-  copilot: z42.optional(
-    z42.object({
-      excludeAgent: z42.optional(z42.union([z42.literal("code-review"), z42.literal("coding-agent")]))
+  copilot: z43.optional(
+    z43.object({
+      excludeAgent: z43.optional(z43.union([z43.literal("code-review"), z43.literal("coding-agent")]))
     })
   ),
-  antigravity: z42.optional(
-    z42.looseObject({
-      trigger: z42.optional(z42.string()),
-      globs: z42.optional(z42.array(z42.string()))
+  antigravity: z43.optional(
+    z43.looseObject({
+      trigger: z43.optional(z43.string()),
+      globs: z43.optional(z43.array(z43.string()))
     })
   )
 });
@@ -10507,20 +10644,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 import { join as join85 } from "path";
-import { z as z43 } from "zod/mini";
-var AntigravityRuleFrontmatterSchema = z43.looseObject({
-  trigger: z43.optional(
-    z43.union([
-      z43.literal("always_on"),
-      z43.literal("glob"),
-      z43.literal("manual"),
-      z43.literal("model_decision"),
-      z43.string()
+import { z as z44 } from "zod/mini";
+var AntigravityRuleFrontmatterSchema = z44.looseObject({
+  trigger: z44.optional(
+    z44.union([
+      z44.literal("always_on"),
+      z44.literal("glob"),
+      z44.literal("manual"),
+      z44.literal("model_decision"),
+      z44.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: z43.optional(z43.string()),
-  description: z43.optional(z43.string())
+  globs: z44.optional(z44.string()),
+  description: z44.optional(z44.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -11099,9 +11236,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 import { join as join89 } from "path";
-import { z as z44 } from "zod/mini";
-var ClaudecodeRuleFrontmatterSchema = z44.object({
-  paths: z44.optional(z44.array(z44.string()))
+import { z as z45 } from "zod/mini";
+var ClaudecodeRuleFrontmatterSchema = z45.object({
+  paths: z45.optional(z45.array(z45.string()))
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -11310,9 +11447,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 import { join as join90 } from "path";
-import { z as z45 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z45.object({
-  description: z45.string()
+import { z as z46 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z46.object({
+  description: z46.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths(_options = {}) {
@@ -11491,11 +11628,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 import { join as join92 } from "path";
-import { z as z46 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z46.object({
-  description: z46.optional(z46.string()),
-  applyTo: z46.optional(z46.string()),
-  excludeAgent: z46.optional(z46.union([z46.literal("code-review"), z46.literal("coding-agent")]))
+import { z as z47 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z47.object({
+  description: z47.optional(z47.string()),
+  applyTo: z47.optional(z47.string()),
+  excludeAgent: z47.optional(z47.union([z47.literal("code-review"), z47.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -11679,11 +11816,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 import { join as join93 } from "path";
-import { z as z47 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z47.object({
-  description: z47.optional(z47.string()),
-  globs: z47.optional(z47.string()),
-  alwaysApply: z47.optional(z47.boolean())
+import { z as z48 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z48.object({
+  description: z48.optional(z48.string()),
+  globs: z48.optional(z48.string()),
+  alwaysApply: z48.optional(z48.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -12790,7 +12927,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z48.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z49.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -12911,8 +13048,7 @@ var toolRuleFactories = /* @__PURE__ */ new Map([
         supportsGlobal: true,
         ruleDiscoveryMode: "toon",
         additionalConventions: {
-          subagents: { subagentClass: GeminiCliSubagent },
-          skills: { skillClass: GeminiCliSkill }
+          subagents: { subagentClass: GeminiCliSubagent }
         }
       }
     }
@@ -13492,60 +13628,60 @@ ${toonContent}`;
 };
 
 // src/types/git-provider.ts
-import { z as z49 } from "zod/mini";
+import { z as z50 } from "zod/mini";
 var ALL_GIT_PROVIDERS = ["github", "gitlab"];
-var GitProviderSchema = z49.enum(ALL_GIT_PROVIDERS);
+var GitProviderSchema = z50.enum(ALL_GIT_PROVIDERS);
 
 // src/lib/github-client.ts
 import { RequestError } from "@octokit/request-error";
 import { Octokit } from "@octokit/rest";
 
 // src/types/fetch.ts
-import { z as z51 } from "zod/mini";
+import { z as z52 } from "zod/mini";
 
 // src/types/fetch-targets.ts
-import { z as z50 } from "zod/mini";
+import { z as z51 } from "zod/mini";
 var ALL_FETCH_TARGETS = ["rulesync", ...ALL_TOOL_TARGETS];
-var FetchTargetSchema = z50.enum(ALL_FETCH_TARGETS);
+var FetchTargetSchema = z51.enum(ALL_FETCH_TARGETS);
 
 // src/types/fetch.ts
-var ConflictStrategySchema = z51.enum(["skip", "overwrite"]);
-var GitHubFileTypeSchema = z51.enum(["file", "dir", "symlink", "submodule"]);
-var GitHubFileEntrySchema = z51.looseObject({
-  name: z51.string(),
-  path: z51.string(),
-  sha: z51.string(),
-  size: z51.number(),
+var ConflictStrategySchema = z52.enum(["skip", "overwrite"]);
+var GitHubFileTypeSchema = z52.enum(["file", "dir", "symlink", "submodule"]);
+var GitHubFileEntrySchema = z52.looseObject({
+  name: z52.string(),
+  path: z52.string(),
+  sha: z52.string(),
+  size: z52.number(),
   type: GitHubFileTypeSchema,
-  download_url: z51.nullable(z51.string())
+  download_url: z52.nullable(z52.string())
 });
-var FetchOptionsSchema = z51.looseObject({
-  target: z51.optional(FetchTargetSchema),
-  features: z51.optional(z51.array(z51.enum(ALL_FEATURES_WITH_WILDCARD))),
-  ref: z51.optional(z51.string()),
-  path: z51.optional(z51.string()),
-  output: z51.optional(z51.string()),
-  conflict: z51.optional(ConflictStrategySchema),
-  token: z51.optional(z51.string()),
-  verbose: z51.optional(z51.boolean()),
-  silent: z51.optional(z51.boolean())
+var FetchOptionsSchema = z52.looseObject({
+  target: z52.optional(FetchTargetSchema),
+  features: z52.optional(z52.array(z52.enum(ALL_FEATURES_WITH_WILDCARD))),
+  ref: z52.optional(z52.string()),
+  path: z52.optional(z52.string()),
+  output: z52.optional(z52.string()),
+  conflict: z52.optional(ConflictStrategySchema),
+  token: z52.optional(z52.string()),
+  verbose: z52.optional(z52.boolean()),
+  silent: z52.optional(z52.boolean())
 });
-var FetchFileStatusSchema = z51.enum(["created", "overwritten", "skipped"]);
-var GitHubRepoInfoSchema = z51.looseObject({
-  default_branch: z51.string(),
-  private: z51.boolean()
+var FetchFileStatusSchema = z52.enum(["created", "overwritten", "skipped"]);
+var GitHubRepoInfoSchema = z52.looseObject({
+  default_branch: z52.string(),
+  private: z52.boolean()
 });
-var GitHubReleaseAssetSchema = z51.looseObject({
-  name: z51.string(),
-  browser_download_url: z51.string(),
-  size: z51.number()
+var GitHubReleaseAssetSchema = z52.looseObject({
+  name: z52.string(),
+  browser_download_url: z52.string(),
+  size: z52.number()
 });
-var GitHubReleaseSchema = z51.looseObject({
-  tag_name: z51.string(),
-  name: z51.nullable(z51.string()),
-  prerelease: z51.boolean(),
-  draft: z51.boolean(),
-  assets: z51.array(GitHubReleaseAssetSchema)
+var GitHubReleaseSchema = z52.looseObject({
+  tag_name: z52.string(),
+  name: z52.nullable(z52.string()),
+  prerelease: z52.boolean(),
+  draft: z52.boolean(),
+  assets: z52.array(GitHubReleaseAssetSchema)
 });
 
 // src/lib/github-client.ts
@@ -13796,6 +13932,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 = [];
@@ -14060,11 +14203,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 }) => {
@@ -14096,6 +14235,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 }))
   );
@@ -14106,14 +14254,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) {
@@ -14232,11 +14374,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(
@@ -14253,7 +14391,6 @@ async function fetchAndConvertToolFiles(params) {
         );
         await writeFileContent(localPath, content);
         logger.debug(`Fetched to temp: ${toolRelativePath}`);
-        return toolRelativePath;
       })
     );
     const outputBasePath = join106(baseDir, outputDir);
@@ -14406,29 +14543,29 @@ import { parse as parseJsonc } from "jsonc-parser";
 import { dirname as dirname2, join as join107, resolve as resolve4 } from "path";
 
 // src/config/config.ts
-import { optional as optional3, z as z52 } from "zod/mini";
-var ConfigParamsSchema = z52.object({
-  baseDirs: z52.array(z52.string()),
+import { optional as optional3, z as z53 } from "zod/mini";
+var ConfigParamsSchema = z53.object({
+  baseDirs: z53.array(z53.string()),
   targets: RulesyncTargetsSchema,
   features: RulesyncFeaturesSchema,
-  verbose: z52.boolean(),
-  delete: z52.boolean(),
+  verbose: z53.boolean(),
+  delete: z53.boolean(),
   // New non-experimental options
-  global: optional3(z52.boolean()),
-  silent: optional3(z52.boolean()),
-  simulateCommands: optional3(z52.boolean()),
-  simulateSubagents: optional3(z52.boolean()),
-  simulateSkills: optional3(z52.boolean()),
-  modularMcp: optional3(z52.boolean()),
-  dryRun: optional3(z52.boolean()),
-  check: optional3(z52.boolean())
+  global: optional3(z53.boolean()),
+  silent: optional3(z53.boolean()),
+  simulateCommands: optional3(z53.boolean()),
+  simulateSubagents: optional3(z53.boolean()),
+  simulateSkills: optional3(z53.boolean()),
+  modularMcp: optional3(z53.boolean()),
+  dryRun: optional3(z53.boolean()),
+  check: optional3(z53.boolean())
 });
-var PartialConfigParamsSchema = z52.partial(ConfigParamsSchema);
-var ConfigFileSchema = z52.object({
-  $schema: optional3(z52.string()),
-  ...z52.partial(ConfigParamsSchema).shape
+var PartialConfigParamsSchema = z53.partial(ConfigParamsSchema);
+var ConfigFileSchema = z53.object({
+  $schema: optional3(z53.string()),
+  ...z53.partial(ConfigParamsSchema).shape
 });
-var RequiredConfigParamsSchema = z52.required(ConfigParamsSchema);
+var RequiredConfigParamsSchema = z53.required(ConfigParamsSchema);
 var CONFLICTING_TARGET_PAIRS = [
   ["augmentcode", "augmentcode-legacy"],
   ["claudecode", "claudecode-legacy"]
@@ -14501,12 +14638,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;
   }
@@ -14687,9 +14857,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();
@@ -14699,6 +14866,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,
@@ -14725,9 +14895,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 };
   }
@@ -14735,6 +14902,9 @@ async function generateIgnoreCore(params) {
   let hasDiff = false;
   const isPreviewMode = config.isPreviewMode();
   for (const toolTarget of intersection(config.getTargets(), IgnoreProcessor.getToolTargets())) {
+    if (!config.getFeatures(toolTarget).includes("ignore")) {
+      continue;
+    }
     for (const baseDir of config.getBaseDirs()) {
       try {
         const processor = new IgnoreProcessor({
@@ -14770,9 +14940,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();
@@ -14782,6 +14949,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,
@@ -14805,9 +14975,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();
@@ -14820,6 +14987,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,
@@ -14842,9 +15012,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();
@@ -14857,6 +15024,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,
@@ -14879,9 +15049,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 = [];
@@ -14895,6 +15062,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,
@@ -14922,9 +15092,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();
@@ -14934,6 +15101,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,
@@ -14973,9 +15143,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}`);
     }
   }
 }
@@ -15070,7 +15240,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 = [];
@@ -15082,11 +15252,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) {
@@ -15296,7 +15464,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();
@@ -15322,7 +15490,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()) {
@@ -15352,7 +15520,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();
@@ -15378,7 +15546,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();
@@ -15404,7 +15572,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();
@@ -15430,7 +15598,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();
@@ -15456,7 +15624,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();
@@ -15769,11 +15937,11 @@ async function initCommand() {
 import { FastMCP } from "fastmcp";
 
 // src/mcp/tools.ts
-import { z as z61 } from "zod/mini";
+import { z as z62 } from "zod/mini";
 
 // src/mcp/commands.ts
 import { basename as basename24, join as join111 } from "path";
-import { z as z53 } from "zod/mini";
+import { z as z54 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -15892,17 +16060,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: z53.object({}),
-  getCommand: z53.object({
-    relativePathFromCwd: z53.string()
+  listCommands: z54.object({}),
+  getCommand: z54.object({
+    relativePathFromCwd: z54.string()
   }),
-  putCommand: z53.object({
-    relativePathFromCwd: z53.string(),
+  putCommand: z54.object({
+    relativePathFromCwd: z54.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: z53.string()
+    body: z54.string()
   }),
-  deleteCommand: z53.object({
-    relativePathFromCwd: z53.string()
+  deleteCommand: z54.object({
+    relativePathFromCwd: z54.string()
   })
 };
 var commandTools = {
@@ -15950,16 +16118,16 @@ var commandTools = {
 };
 
 // src/mcp/generate.ts
-import { z as z54 } from "zod/mini";
-var generateOptionsSchema = z54.object({
-  targets: z54.optional(z54.array(z54.string())),
-  features: z54.optional(z54.array(z54.string())),
-  delete: z54.optional(z54.boolean()),
-  global: z54.optional(z54.boolean()),
-  simulateCommands: z54.optional(z54.boolean()),
-  simulateSubagents: z54.optional(z54.boolean()),
-  simulateSkills: z54.optional(z54.boolean()),
-  modularMcp: z54.optional(z54.boolean())
+import { z as z55 } from "zod/mini";
+var generateOptionsSchema = z55.object({
+  targets: z55.optional(z55.array(z55.string())),
+  features: z55.optional(z55.array(z55.string())),
+  delete: z55.optional(z55.boolean()),
+  global: z55.optional(z55.boolean()),
+  simulateCommands: z55.optional(z55.boolean()),
+  simulateSubagents: z55.optional(z55.boolean()),
+  simulateSkills: z55.optional(z55.boolean()),
+  modularMcp: z55.optional(z55.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -16039,7 +16207,7 @@ var generateTools = {
 
 // src/mcp/ignore.ts
 import { join as join112 } from "path";
-import { z as z55 } from "zod/mini";
+import { z as z56 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = join112(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -16096,11 +16264,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z55.object({}),
-  putIgnoreFile: z55.object({
-    content: z55.string()
+  getIgnoreFile: z56.object({}),
+  putIgnoreFile: z56.object({
+    content: z56.string()
   }),
-  deleteIgnoreFile: z55.object({})
+  deleteIgnoreFile: z56.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -16133,11 +16301,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-import { z as z56 } from "zod/mini";
-var importOptionsSchema = z56.object({
-  target: z56.string(),
-  features: z56.optional(z56.array(z56.string())),
-  global: z56.optional(z56.boolean())
+import { z as z57 } from "zod/mini";
+var importOptionsSchema = z57.object({
+  target: z57.string(),
+  features: z57.optional(z57.array(z57.string())),
+  global: z57.optional(z57.boolean())
 });
 async function executeImport(options) {
   try {
@@ -16207,7 +16375,7 @@ var importTools = {
 
 // src/mcp/mcp.ts
 import { join as join113 } from "path";
-import { z as z57 } from "zod/mini";
+import { z as z58 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -16297,11 +16465,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z57.object({}),
-  putMcpFile: z57.object({
-    content: z57.string()
+  getMcpFile: z58.object({}),
+  putMcpFile: z58.object({
+    content: z58.string()
   }),
-  deleteMcpFile: z57.object({})
+  deleteMcpFile: z58.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -16335,7 +16503,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 import { basename as basename25, join as join114 } from "path";
-import { z as z58 } from "zod/mini";
+import { z as z59 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -16454,17 +16622,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z58.object({}),
-  getRule: z58.object({
-    relativePathFromCwd: z58.string()
+  listRules: z59.object({}),
+  getRule: z59.object({
+    relativePathFromCwd: z59.string()
   }),
-  putRule: z58.object({
-    relativePathFromCwd: z58.string(),
+  putRule: z59.object({
+    relativePathFromCwd: z59.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z58.string()
+    body: z59.string()
   }),
-  deleteRule: z58.object({
-    relativePathFromCwd: z58.string()
+  deleteRule: z59.object({
+    relativePathFromCwd: z59.string()
   })
 };
 var ruleTools = {
@@ -16513,7 +16681,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 import { basename as basename26, dirname as dirname3, join as join115 } from "path";
-import { z as z59 } from "zod/mini";
+import { z as z60 } from "zod/mini";
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -16681,23 +16849,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = z59.object({
-  name: z59.string(),
-  body: z59.string()
+var McpSkillFileSchema = z60.object({
+  name: z60.string(),
+  body: z60.string()
 });
 var skillToolSchemas = {
-  listSkills: z59.object({}),
-  getSkill: z59.object({
-    relativeDirPathFromCwd: z59.string()
+  listSkills: z60.object({}),
+  getSkill: z60.object({
+    relativeDirPathFromCwd: z60.string()
   }),
-  putSkill: z59.object({
-    relativeDirPathFromCwd: z59.string(),
+  putSkill: z60.object({
+    relativeDirPathFromCwd: z60.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: z59.string(),
-    otherFiles: z59.optional(z59.array(McpSkillFileSchema))
+    body: z60.string(),
+    otherFiles: z60.optional(z60.array(McpSkillFileSchema))
   }),
-  deleteSkill: z59.object({
-    relativeDirPathFromCwd: z59.string()
+  deleteSkill: z60.object({
+    relativeDirPathFromCwd: z60.string()
   })
 };
 var skillTools = {
@@ -16747,7 +16915,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 import { basename as basename27, join as join116 } from "path";
-import { z as z60 } from "zod/mini";
+import { z as z61 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -16871,17 +17039,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z60.object({}),
-  getSubagent: z60.object({
-    relativePathFromCwd: z60.string()
+  listSubagents: z61.object({}),
+  getSubagent: z61.object({
+    relativePathFromCwd: z61.string()
   }),
-  putSubagent: z60.object({
-    relativePathFromCwd: z60.string(),
+  putSubagent: z61.object({
+    relativePathFromCwd: z61.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z60.string()
+    body: z61.string()
   }),
-  deleteSubagent: z60.object({
-    relativePathFromCwd: z60.string()
+  deleteSubagent: z61.object({
+    relativePathFromCwd: z61.string()
   })
 };
 var subagentTools = {
@@ -16929,7 +17097,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = z61.enum([
+var rulesyncFeatureSchema = z62.enum([
   "rule",
   "command",
   "subagent",
@@ -16939,21 +17107,21 @@ var rulesyncFeatureSchema = z61.enum([
   "generate",
   "import"
 ]);
-var rulesyncOperationSchema = z61.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = z61.object({
-  name: z61.string(),
-  body: z61.string()
+var rulesyncOperationSchema = z62.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = z62.object({
+  name: z62.string(),
+  body: z62.string()
 });
-var rulesyncToolSchema = z61.object({
+var rulesyncToolSchema = z62.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: z61.optional(z61.string()),
-  frontmatter: z61.optional(z61.unknown()),
-  body: z61.optional(z61.string()),
-  otherFiles: z61.optional(z61.array(skillFileSchema)),
-  content: z61.optional(z61.string()),
-  generateOptions: z61.optional(generateOptionsSchema),
-  importOptions: z61.optional(importOptionsSchema)
+  targetPathFromCwd: z62.optional(z62.string()),
+  frontmatter: z62.optional(z62.unknown()),
+  body: z62.optional(z62.string()),
+  otherFiles: z62.optional(z62.array(skillFileSchema)),
+  content: z62.optional(z62.string()),
+  generateOptions: z62.optional(generateOptionsSchema),
+  importOptions: z62.optional(importOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -17512,7 +17680,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 Command();
   const version = getVersion();