rulesync 3.32.0 → 3.34.0

package/dist/index.cjs

@@ -102,7 +102,7 @@ var Logger = class {
 var logger = new Logger();
 
 // src/cli/commands/generate.ts
-var import_es_toolkit2 = require("es-toolkit");
+var import_es_toolkit3 = require("es-toolkit");
 
 // src/config/config-resolver.ts
 var import_node_path2 = require("path");
@@ -113,6 +113,7 @@ var import_node_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path = require("path");
+var import_es_toolkit = require("es-toolkit");
 async function ensureDir(dirPath) {
   try {
     await (0, import_promises.stat)(dirPath);
@@ -240,6 +241,13 @@ function validateBaseDir(baseDir) {
   }
   checkPathTraversal({ relativePath: baseDir, intendedRootDir: process.cwd() });
 }
+function toKebabCaseFilename(filename) {
+  const lastDotIndex = filename.lastIndexOf(".");
+  const extension = lastDotIndex > 0 ? filename.slice(lastDotIndex) : "";
+  const nameWithoutExt = lastDotIndex > 0 ? filename.slice(0, lastDotIndex) : filename;
+  const kebabName = (0, import_es_toolkit.kebabCase)(nameWithoutExt);
+  return kebabName + extension;
+}
 
 // src/config/config.ts
 var import_mini3 = require("zod/mini");
@@ -2347,7 +2355,7 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
 
 // src/features/ignore/claudecode-ignore.ts
 var import_node_path20 = require("path");
-var import_es_toolkit = require("es-toolkit");
+var import_es_toolkit2 = require("es-toolkit");
 var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
   constructor(params) {
     super(params);
@@ -2397,11 +2405,19 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
     const exists = await fileExists(filePath);
     const existingFileContent = exists ? await readFileContent(filePath) : "{}";
     const existingJsonValue = JSON.parse(existingFileContent);
+    const existingDenies = existingJsonValue.permissions?.deny ?? [];
+    const preservedDenies = existingDenies.filter((deny) => {
+      const isReadPattern = deny.startsWith("Read(") && deny.endsWith(")");
+      if (isReadPattern) {
+        return deniedValues.includes(deny);
+      }
+      return true;
+    });
     const jsonValue = {
       ...existingJsonValue,
       permissions: {
         ...existingJsonValue.permissions,
-        deny: (0, import_es_toolkit.uniq)([...existingJsonValue.permissions?.deny ?? [], ...deniedValues].toSorted())
+        deny: (0, import_es_toolkit2.uniq)([...preservedDenies, ...deniedValues].toSorted())
       }
     };
     return new _ClaudecodeIgnore({
@@ -3536,6 +3552,12 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
 
 // src/features/mcp/copilot-mcp.ts
 var import_node_path35 = require("path");
+function convertToCopilotFormat(mcpServers) {
+  return { servers: mcpServers };
+}
+function convertFromCopilotFormat(copilotConfig) {
+  return copilotConfig.servers ?? {};
+}
 var CopilotMcp = class _CopilotMcp extends ToolMcp {
   json;
   constructor(params) {
@@ -3575,16 +3597,20 @@ var CopilotMcp = class _CopilotMcp extends ToolMcp {
     rulesyncMcp,
     validate = true
   }) {
+    const copilotConfig = convertToCopilotFormat(rulesyncMcp.getMcpServers());
     return new _CopilotMcp({
       baseDir,
       relativeDirPath: this.getSettablePaths().relativeDirPath,
       relativeFilePath: this.getSettablePaths().relativeFilePath,
-      fileContent: rulesyncMcp.getFileContent(),
+      fileContent: JSON.stringify(copilotConfig, null, 2),
       validate
     });
   }
   toRulesyncMcp() {
-    return this.toRulesyncMcpDefault();
+    const mcpServers = convertFromCopilotFormat(this.json);
+    return this.toRulesyncMcpDefault({
+      fileContent: JSON.stringify({ mcpServers }, null, 2)
+    });
   }
   validate() {
     return { success: true, error: null };
@@ -3968,6 +3994,37 @@ var OpencodeMcp = class _OpencodeMcp extends ToolMcp {
 
 // src/features/mcp/roo-mcp.ts
 var import_node_path40 = require("path");
+function isRooMcpServers(value) {
+  return value !== void 0 && value !== null && typeof value === "object";
+}
+function convertToRooFormat(mcpServers) {
+  return Object.fromEntries(
+    Object.entries(mcpServers).map(([serverName, serverConfig]) => {
+      const converted = { ...serverConfig };
+      if (serverConfig.type === "http") {
+        converted.type = "streamable-http";
+      }
+      if (serverConfig.transport === "http") {
+        converted.transport = "streamable-http";
+      }
+      return [serverName, converted];
+    })
+  );
+}
+function convertFromRooFormat(mcpServers) {
+  return Object.fromEntries(
+    Object.entries(mcpServers).map(([serverName, serverConfig]) => {
+      const converted = { ...serverConfig };
+      if (serverConfig.type === "streamable-http") {
+        converted.type = "http";
+      }
+      if (serverConfig.transport === "streamable-http") {
+        converted.transport = "http";
+      }
+      return [serverName, converted];
+    })
+  );
+}
 var RooMcp = class _RooMcp extends ToolMcp {
   json;
   constructor(params) {
@@ -4007,7 +4064,9 @@ var RooMcp = class _RooMcp extends ToolMcp {
     rulesyncMcp,
     validate = true
   }) {
-    const fileContent = rulesyncMcp.getFileContent();
+    const mcpServers = rulesyncMcp.getMcpServers();
+    const convertedMcpServers = convertToRooFormat(mcpServers);
+    const fileContent = JSON.stringify({ mcpServers: convertedMcpServers }, null, 2);
     return new _RooMcp({
       baseDir,
       relativeDirPath: this.getSettablePaths().relativeDirPath,
@@ -4017,7 +4076,11 @@ var RooMcp = class _RooMcp extends ToolMcp {
     });
   }
   toRulesyncMcp() {
-    return this.toRulesyncMcpDefault();
+    const rawMcpServers = isRooMcpServers(this.json.mcpServers) ? this.json.mcpServers : {};
+    const convertedMcpServers = convertFromRooFormat(rawMcpServers);
+    return this.toRulesyncMcpDefault({
+      fileContent: JSON.stringify({ mcpServers: convertedMcpServers }, null, 2)
+    });
   }
   validate() {
     return { success: true, error: null };
@@ -4260,19 +4323,21 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path84 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini33 = require("zod/mini");
-
-// src/features/skills/codexcli-skill.ts
-var import_node_path44 = require("path");
-var import_mini20 = require("zod/mini");
+var import_mini34 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
 
-// src/features/skills/rulesync-skill.ts
-var import_node_path42 = require("path");
+// src/features/skills/agentsmd-skill.ts
+var import_node_path44 = require("path");
+
+// src/features/skills/simulated-skill.ts
+var import_node_path43 = require("path");
 var import_mini19 = require("zod/mini");
 
+// src/features/skills/tool-skill.ts
+var import_node_path42 = require("path");
+
 // src/types/ai-dir.ts
 var import_node_path41 = __toESM(require("path"), 1);
 var AiDir = class {
@@ -4385,113 +4450,7 @@ var AiDir = class {
   }
 };
 
-// src/features/skills/rulesync-skill.ts
-var RulesyncSkillFrontmatterSchemaInternal = import_mini19.z.object({
-  name: import_mini19.z.string(),
-  description: import_mini19.z.string(),
-  targets: import_mini19.z._default(RulesyncTargetsSchema, ["*"]),
-  claudecode: import_mini19.z.optional(
-    import_mini19.z.object({
-      "allowed-tools": import_mini19.z.optional(import_mini19.z.array(import_mini19.z.string()))
-    })
-  )
-});
-var RulesyncSkillFrontmatterSchema = RulesyncSkillFrontmatterSchemaInternal;
-var RulesyncSkill = class _RulesyncSkill extends AiDir {
-  constructor({
-    baseDir = process.cwd(),
-    relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH,
-    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() {
-    return {
-      relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH
-    };
-  }
-  getFrontmatter() {
-    if (!this.mainFile?.frontmatter) {
-      throw new Error("Frontmatter is not defined");
-    }
-    const result = RulesyncSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
-    return result;
-  }
-  getBody() {
-    return this.mainFile?.body ?? "";
-  }
-  validate() {
-    const result = RulesyncSkillFrontmatterSchema.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 };
-  }
-  static async fromDir({
-    baseDir = process.cwd(),
-    relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH,
-    dirName,
-    global = false
-  }) {
-    const skillDirPath = (0, import_node_path42.join)(baseDir, relativeDirPath, dirName);
-    const skillFilePath = (0, import_node_path42.join)(skillDirPath, SKILL_FILE_NAME);
-    if (!await fileExists(skillFilePath)) {
-      throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
-    }
-    const fileContent = await readFileContent(skillFilePath);
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncSkillFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${skillFilePath}: ${formatError(result.error)}`);
-    }
-    const otherFiles = await this.collectOtherFiles(
-      baseDir,
-      relativeDirPath,
-      dirName,
-      SKILL_FILE_NAME
-    );
-    return new _RulesyncSkill({
-      baseDir,
-      relativeDirPath,
-      dirName,
-      frontmatter: result.data,
-      body: content.trim(),
-      otherFiles,
-      validate: true,
-      global
-    });
-  }
-};
-
 // src/features/skills/tool-skill.ts
-var import_node_path43 = require("path");
 var ToolSkill = class extends AiDir {
   /**
    * Get the settable paths for this tool's skill directories.
@@ -4565,8 +4524,8 @@ var ToolSkill = class extends AiDir {
   }) {
     const settablePaths = getSettablePaths({ global });
     const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
-    const skillDirPath = (0, import_node_path43.join)(baseDir, actualRelativeDirPath, dirName);
-    const skillFilePath = (0, import_node_path43.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillDirPath = (0, import_node_path42.join)(baseDir, actualRelativeDirPath, dirName);
+    const skillFilePath = (0, import_node_path42.join)(skillDirPath, SKILL_FILE_NAME);
     if (!await fileExists(skillFilePath)) {
       throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
     }
@@ -4590,21 +4549,22 @@ var ToolSkill = class extends AiDir {
   }
 };
 
-// src/features/skills/codexcli-skill.ts
-var CodexCliSkillFrontmatterSchema = import_mini20.z.object({
-  name: import_mini20.z.string(),
-  description: import_mini20.z.string()
+// src/features/skills/simulated-skill.ts
+var SimulatedSkillFrontmatterSchema = import_mini19.z.object({
+  name: import_mini19.z.string(),
+  description: import_mini19.z.string()
 });
-var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
+var SimulatedSkill = class extends ToolSkill {
+  frontmatter;
+  body;
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path44.join)(".codex", "skills"),
+    relativeDirPath,
     dirName,
     frontmatter,
     body,
     otherFiles = [],
-    validate = true,
-    global = false
+    validate = true
   }) {
     super({
       baseDir,
@@ -4616,42 +4576,37 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
         frontmatter: { ...frontmatter }
       },
       otherFiles,
-      global
+      global: false
+      // Simulated skills are project mode only
     });
     if (validate) {
-      const result = this.validate();
+      const result = SimulatedSkillFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
-        throw result.error;
+        throw new Error(
+          `Invalid frontmatter in ${(0, import_node_path43.join)(relativeDirPath, dirName)}: ${formatError(result.error)}`
+        );
       }
     }
+    this.frontmatter = frontmatter;
+    this.body = body;
   }
-  static getSettablePaths({ global = false } = {}) {
-    if (!global) {
-      throw new Error("CodexCliSkill only supports global mode. Please pass { global: true }.");
-    }
-    return {
-      relativeDirPath: (0, import_node_path44.join)(".codex", "skills")
-    };
+  getBody() {
+    return this.body;
   }
   getFrontmatter() {
-    if (!this.mainFile?.frontmatter) {
-      throw new Error("Frontmatter is not defined");
-    }
-    const result = CodexCliSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
-    return result;
+    return this.frontmatter;
   }
-  getBody() {
-    return this.mainFile?.body ?? "";
+  toRulesyncSkill() {
+    throw new Error("Not implemented because it is a SIMULATED skill.");
   }
   validate() {
-    if (!this.mainFile) {
-      return {
-        success: false,
-        error: new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
-      };
+    if (!this.frontmatter) {
+      return { success: true, error: null };
     }
-    const result = CodexCliSkillFrontmatterSchema.safeParse(this.mainFile.frontmatter);
-    if (!result.success) {
+    const result = SimulatedSkillFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
       return {
         success: false,
         error: new Error(
@@ -4659,98 +4614,141 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
         )
       };
     }
-    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: this.relativeDirPath,
-      dirName: this.getDirName(),
-      frontmatter: rulesyncFrontmatter,
-      body: this.getBody(),
-      otherFiles: this.getOtherFiles(),
-      validate: true,
-      global: this.global
-    });
   }
-  static fromRulesyncSkill({
+  static fromRulesyncSkillDefault({
     rulesyncSkill,
-    validate = true,
-    global = false
+    validate = true
   }) {
-    const settablePaths = _CodexCliSkill.getSettablePaths({ global });
     const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
-    const codexFrontmatter = {
+    const simulatedFrontmatter = {
       name: rulesyncFrontmatter.name,
       description: rulesyncFrontmatter.description
     };
-    return new _CodexCliSkill({
+    return {
       baseDir: rulesyncSkill.getBaseDir(),
-      relativeDirPath: settablePaths.relativeDirPath,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
       dirName: rulesyncSkill.getDirName(),
-      frontmatter: codexFrontmatter,
+      frontmatter: simulatedFrontmatter,
       body: rulesyncSkill.getBody(),
       otherFiles: rulesyncSkill.getOtherFiles(),
-      validate,
-      global
-    });
-  }
-  static isTargetedByRulesyncSkill(rulesyncSkill) {
-    const targets = rulesyncSkill.getFrontmatter().targets;
-    return targets.includes("*") || targets.includes("codexcli");
+      validate
+    };
   }
-  static async fromDir(params) {
-    const loaded = await this.loadSkillDirContent({
-      ...params,
-      getSettablePaths: _CodexCliSkill.getSettablePaths
-    });
-    const result = CodexCliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
-    if (!result.success) {
-      const skillDirPath = (0, import_node_path44.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
-      throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path44.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
-      );
-    }
-    return new _CodexCliSkill({
-      baseDir: loaded.baseDir,
-      relativeDirPath: loaded.relativeDirPath,
-      dirName: loaded.dirName,
+  static async fromDirDefault({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName
+  }) {
+    const settablePaths = this.getSettablePaths();
+    const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
+    const skillDirPath = (0, import_node_path43.join)(baseDir, actualRelativeDirPath, dirName);
+    const skillFilePath = (0, import_node_path43.join)(skillDirPath, SKILL_FILE_NAME);
+    if (!await fileExists(skillFilePath)) {
+      throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
+    }
+    const fileContent = await readFileContent(skillFilePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = SimulatedSkillFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${skillFilePath}: ${formatError(result.error)}`);
+    }
+    const otherFiles = await this.collectOtherFiles(
+      baseDir,
+      actualRelativeDirPath,
+      dirName,
+      SKILL_FILE_NAME
+    );
+    return {
+      baseDir,
+      relativeDirPath: actualRelativeDirPath,
+      dirName,
       frontmatter: result.data,
-      body: loaded.body,
-      otherFiles: loaded.otherFiles,
-      validate: true,
-      global: loaded.global
+      body: content.trim(),
+      otherFiles,
+      validate: true
+    };
+  }
+  /**
+   * Check if a RulesyncSkill should be converted to this simulated skill type.
+   * Uses the targets field in the RulesyncSkill frontmatter to determine targeting.
+   */
+  static isTargetedByRulesyncSkillDefault({
+    rulesyncSkill,
+    toolTarget
+  }) {
+    const frontmatter = rulesyncSkill.getFrontmatter();
+    const targets = frontmatter.targets;
+    if (targets.includes("*")) {
+      return true;
+    }
+    return targets.includes(toolTarget);
+  }
+  /**
+   * Get the settable paths for this tool's skill directories.
+   * Must be implemented by concrete subclasses.
+   */
+  static getSettablePaths(_options) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+};
+
+// src/features/skills/agentsmd-skill.ts
+var AgentsmdSkill = class _AgentsmdSkill extends SimulatedSkill {
+  static getSettablePaths(options) {
+    if (options?.global) {
+      throw new Error("AgentsmdSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: (0, import_node_path44.join)(".agents", "skills")
+    };
+  }
+  static async fromDir(params) {
+    const baseParams = await this.fromDirDefault(params);
+    return new _AgentsmdSkill(baseParams);
+  }
+  static fromRulesyncSkill(params) {
+    const baseParams = {
+      ...this.fromRulesyncSkillDefault(params),
+      relativeDirPath: this.getSettablePaths().relativeDirPath
+    };
+    return new _AgentsmdSkill(baseParams);
+  }
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    return this.isTargetedByRulesyncSkillDefault({
+      rulesyncSkill,
+      toolTarget: "agentsmd"
     });
   }
 };
 
-// src/features/skills/copilot-skill.ts
+// src/features/skills/codexcli-skill.ts
 var import_node_path46 = require("path");
+var import_mini21 = require("zod/mini");
 
-// src/features/skills/simulated-skill.ts
+// src/features/skills/rulesync-skill.ts
 var import_node_path45 = require("path");
-var import_mini21 = require("zod/mini");
-var SimulatedSkillFrontmatterSchema = import_mini21.z.object({
-  name: import_mini21.z.string(),
-  description: import_mini21.z.string()
+var import_mini20 = require("zod/mini");
+var RulesyncSkillFrontmatterSchemaInternal = import_mini20.z.object({
+  name: import_mini20.z.string(),
+  description: import_mini20.z.string(),
+  targets: import_mini20.z._default(RulesyncTargetsSchema, ["*"]),
+  claudecode: import_mini20.z.optional(
+    import_mini20.z.object({
+      "allowed-tools": import_mini20.z.optional(import_mini20.z.array(import_mini20.z.string()))
+    })
+  )
 });
-var SimulatedSkill = class extends ToolSkill {
-  frontmatter;
-  body;
+var RulesyncSkillFrontmatterSchema = RulesyncSkillFrontmatterSchemaInternal;
+var RulesyncSkill = class _RulesyncSkill extends AiDir {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath,
+    relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH,
     dirName,
     frontmatter,
     body,
     otherFiles = [],
-    validate = true
+    validate = true,
+    global = false
   }) {
     super({
       baseDir,
@@ -4762,37 +4760,33 @@ var SimulatedSkill = class extends ToolSkill {
         frontmatter: { ...frontmatter }
       },
       otherFiles,
-      global: false
-      // Simulated skills are project mode only
+      global
     });
     if (validate) {
-      const result = SimulatedSkillFrontmatterSchema.safeParse(frontmatter);
+      const result = this.validate();
       if (!result.success) {
-        throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path45.join)(relativeDirPath, dirName)}: ${formatError(result.error)}`
-        );
+        throw result.error;
       }
     }
-    this.frontmatter = frontmatter;
-    this.body = body;
   }
-  getBody() {
-    return this.body;
+  static getSettablePaths() {
+    return {
+      relativeDirPath: RULESYNC_SKILLS_RELATIVE_DIR_PATH
+    };
   }
   getFrontmatter() {
-    return this.frontmatter;
+    if (!this.mainFile?.frontmatter) {
+      throw new Error("Frontmatter is not defined");
+    }
+    const result = RulesyncSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
+    return result;
   }
-  toRulesyncSkill() {
-    throw new Error("Not implemented because it is a SIMULATED skill.");
+  getBody() {
+    return this.mainFile?.body ?? "";
   }
   validate() {
-    if (!this.frontmatter) {
-      return { success: true, error: null };
-    }
-    const result = SimulatedSkillFrontmatterSchema.safeParse(this.frontmatter);
-    if (result.success) {
-      return { success: true, error: null };
-    } else {
+    const result = RulesyncSkillFrontmatterSchema.safeParse(this.mainFile?.frontmatter);
+    if (!result.success) {
       return {
         success: false,
         error: new Error(
@@ -4800,92 +4794,193 @@ var SimulatedSkill = class extends ToolSkill {
         )
       };
     }
+    return { success: true, error: null };
   }
-  static fromRulesyncSkillDefault({
-    rulesyncSkill,
-    validate = true
-  }) {
-    const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
-    const simulatedFrontmatter = {
-      name: rulesyncFrontmatter.name,
-      description: rulesyncFrontmatter.description
-    };
-    return {
-      baseDir: rulesyncSkill.getBaseDir(),
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      dirName: rulesyncSkill.getDirName(),
-      frontmatter: simulatedFrontmatter,
-      body: rulesyncSkill.getBody(),
-      otherFiles: rulesyncSkill.getOtherFiles(),
-      validate
-    };
-  }
-  static async fromDirDefault({
+  static async fromDir({
     baseDir = process.cwd(),
-    relativeDirPath,
-    dirName
+    relativeDirPath = RULESYNC_SKILLS_RELATIVE_DIR_PATH,
+    dirName,
+    global = false
   }) {
-    const settablePaths = this.getSettablePaths();
-    const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
-    const skillDirPath = (0, import_node_path45.join)(baseDir, actualRelativeDirPath, dirName);
+    const skillDirPath = (0, import_node_path45.join)(baseDir, relativeDirPath, dirName);
     const skillFilePath = (0, import_node_path45.join)(skillDirPath, SKILL_FILE_NAME);
     if (!await fileExists(skillFilePath)) {
       throw new Error(`${SKILL_FILE_NAME} not found in ${skillDirPath}`);
     }
     const fileContent = await readFileContent(skillFilePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = SimulatedSkillFrontmatterSchema.safeParse(frontmatter);
+    const result = RulesyncSkillFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${skillFilePath}: ${formatError(result.error)}`);
     }
     const otherFiles = await this.collectOtherFiles(
       baseDir,
-      actualRelativeDirPath,
+      relativeDirPath,
       dirName,
       SKILL_FILE_NAME
     );
-    return {
+    return new _RulesyncSkill({
       baseDir,
-      relativeDirPath: actualRelativeDirPath,
+      relativeDirPath,
       dirName,
       frontmatter: result.data,
       body: content.trim(),
       otherFiles,
-      validate: true
+      validate: true,
+      global
+    });
+  }
+};
+
+// src/features/skills/codexcli-skill.ts
+var CodexCliSkillFrontmatterSchema = import_mini21.z.object({
+  name: import_mini21.z.string(),
+  description: import_mini21.z.string()
+});
+var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = (0, import_node_path46.join)(".codex", "skills"),
+    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 = false } = {}) {
+    if (!global) {
+      throw new Error("CodexCliSkill only supports global mode. Please pass { global: true }.");
+    }
+    return {
+      relativeDirPath: (0, import_node_path46.join)(".codex", "skills")
     };
   }
-  /**
-   * Check if a RulesyncSkill should be converted to this simulated skill type.
-   * Uses the targets field in the RulesyncSkill frontmatter to determine targeting.
-   */
-  static isTargetedByRulesyncSkillDefault({
+  getFrontmatter() {
+    if (!this.mainFile?.frontmatter) {
+      throw new Error("Frontmatter is not defined");
+    }
+    const result = CodexCliSkillFrontmatterSchema.parse(this.mainFile.frontmatter);
+    return result;
+  }
+  getBody() {
+    return this.mainFile?.body ?? "";
+  }
+  validate() {
+    if (!this.mainFile) {
+      return {
+        success: false,
+        error: new Error(`${this.getDirPath()}: ${SKILL_FILE_NAME} file does not exist`)
+      };
+    }
+    const result = CodexCliSkillFrontmatterSchema.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: this.relativeDirPath,
+      dirName: this.getDirName(),
+      frontmatter: rulesyncFrontmatter,
+      body: this.getBody(),
+      otherFiles: this.getOtherFiles(),
+      validate: true,
+      global: this.global
+    });
+  }
+  static fromRulesyncSkill({
     rulesyncSkill,
-    toolTarget
+    validate = true,
+    global = false
   }) {
-    const frontmatter = rulesyncSkill.getFrontmatter();
-    const targets = frontmatter.targets;
-    if (targets.includes("*")) {
-      return true;
-    }
-    return targets.includes(toolTarget);
+    const settablePaths = _CodexCliSkill.getSettablePaths({ global });
+    const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+    const codexFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description
+    };
+    return new _CodexCliSkill({
+      baseDir: rulesyncSkill.getBaseDir(),
+      relativeDirPath: settablePaths.relativeDirPath,
+      dirName: rulesyncSkill.getDirName(),
+      frontmatter: codexFrontmatter,
+      body: rulesyncSkill.getBody(),
+      otherFiles: rulesyncSkill.getOtherFiles(),
+      validate,
+      global
+    });
   }
-  /**
-   * Get the settable paths for this tool's skill directories.
-   * Must be implemented by concrete subclasses.
-   */
-  static getSettablePaths(_options) {
-    throw new Error("Please implement this method in the subclass.");
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    const targets = rulesyncSkill.getFrontmatter().targets;
+    return targets.includes("*") || targets.includes("codexcli");
+  }
+  static async fromDir(params) {
+    const loaded = await this.loadSkillDirContent({
+      ...params,
+      getSettablePaths: _CodexCliSkill.getSettablePaths
+    });
+    const result = CodexCliSkillFrontmatterSchema.safeParse(loaded.frontmatter);
+    if (!result.success) {
+      const skillDirPath = (0, import_node_path46.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      throw new Error(
+        `Invalid frontmatter in ${(0, import_node_path46.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+      );
+    }
+    return new _CodexCliSkill({
+      baseDir: loaded.baseDir,
+      relativeDirPath: loaded.relativeDirPath,
+      dirName: loaded.dirName,
+      frontmatter: result.data,
+      body: loaded.body,
+      otherFiles: loaded.otherFiles,
+      validate: true,
+      global: loaded.global
+    });
   }
 };
 
 // src/features/skills/copilot-skill.ts
+var import_node_path47 = require("path");
 var CopilotSkill = class _CopilotSkill extends SimulatedSkill {
   static getSettablePaths(options) {
     if (options?.global) {
       throw new Error("CopilotSkill does not support global mode.");
     }
     return {
-      relativeDirPath: (0, import_node_path46.join)(".github", "skills")
+      relativeDirPath: (0, import_node_path47.join)(".github", "skills")
     };
   }
   static async fromDir(params) {
@@ -4908,14 +5003,14 @@ var CopilotSkill = class _CopilotSkill extends SimulatedSkill {
 };
 
 // src/features/skills/cursor-skill.ts
-var import_node_path47 = require("path");
+var import_node_path48 = require("path");
 var CursorSkill = class _CursorSkill extends SimulatedSkill {
   static getSettablePaths(options) {
     if (options?.global) {
       throw new Error("CursorSkill does not support global mode.");
     }
     return {
-      relativeDirPath: (0, import_node_path47.join)(".cursor", "skills")
+      relativeDirPath: (0, import_node_path48.join)(".cursor", "skills")
     };
   }
   static async fromDir(params) {
@@ -4937,12 +5032,42 @@ var CursorSkill = class _CursorSkill extends SimulatedSkill {
   }
 };
 
+// src/features/skills/geminicli-skill.ts
+var import_node_path49 = 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_path49.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"
+    });
+  }
+};
+
 // src/features/skills/skills-processor.ts
 var import_node_path52 = require("path");
 var import_mini23 = require("zod/mini");
 
 // src/types/dir-feature-processor.ts
-var import_node_path48 = require("path");
+var import_node_path50 = require("path");
 var DirFeatureProcessor = class {
   baseDir;
   constructor({ baseDir = process.cwd() }) {
@@ -4964,14 +5089,14 @@ var DirFeatureProcessor = class {
       await ensureDir(dirPath);
       const mainFile = aiDir.getMainFile();
       if (mainFile) {
-        const mainFilePath = (0, import_node_path48.join)(dirPath, mainFile.name);
+        const mainFilePath = (0, import_node_path50.join)(dirPath, mainFile.name);
         const content = stringifyFrontmatter(mainFile.body, mainFile.frontmatter);
         const contentWithNewline = addTrailingNewline(content);
         await writeFileContent(mainFilePath, contentWithNewline);
       }
       const otherFiles = aiDir.getOtherFiles();
       for (const file of otherFiles) {
-        const filePath = (0, import_node_path48.join)(dirPath, file.relativeFilePathToDirPath);
+        const filePath = (0, import_node_path50.join)(dirPath, file.relativeFilePathToDirPath);
         const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
         await writeFileContent(filePath, contentWithNewline);
       }
@@ -4985,38 +5110,8 @@ var DirFeatureProcessor = class {
   }
 };
 
-// src/features/skills/agentsmd-skill.ts
-var import_node_path49 = require("path");
-var AgentsmdSkill = class _AgentsmdSkill extends SimulatedSkill {
-  static getSettablePaths(options) {
-    if (options?.global) {
-      throw new Error("AgentsmdSkill does not support global mode.");
-    }
-    return {
-      relativeDirPath: (0, import_node_path49.join)(".agents", "skills")
-    };
-  }
-  static async fromDir(params) {
-    const baseParams = await this.fromDirDefault(params);
-    return new _AgentsmdSkill(baseParams);
-  }
-  static fromRulesyncSkill(params) {
-    const baseParams = {
-      ...this.fromRulesyncSkillDefault(params),
-      relativeDirPath: this.getSettablePaths().relativeDirPath
-    };
-    return new _AgentsmdSkill(baseParams);
-  }
-  static isTargetedByRulesyncSkill(rulesyncSkill) {
-    return this.isTargetedByRulesyncSkillDefault({
-      rulesyncSkill,
-      toolTarget: "agentsmd"
-    });
-  }
-};
-
 // src/features/skills/claudecode-skill.ts
-var import_node_path50 = require("path");
+var import_node_path51 = require("path");
 var import_mini22 = require("zod/mini");
 var ClaudecodeSkillFrontmatterSchema = import_mini22.z.object({
   name: import_mini22.z.string(),
@@ -5026,7 +5121,7 @@ var ClaudecodeSkillFrontmatterSchema = import_mini22.z.object({
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
     baseDir = process.cwd(),
-    relativeDirPath = (0, import_node_path50.join)(".claude", "skills"),
+    relativeDirPath = (0, import_node_path51.join)(".claude", "skills"),
     dirName,
     frontmatter,
     body,
@@ -5057,7 +5152,7 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
     global: _global = false
   } = {}) {
     return {
-      relativeDirPath: (0, import_node_path50.join)(".claude", "skills")
+      relativeDirPath: (0, import_node_path51.join)(".claude", "skills")
     };
   }
   getFrontmatter() {
@@ -5144,9 +5239,9 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
     });
     const result = ClaudecodeSkillFrontmatterSchema.safeParse(loaded.frontmatter);
     if (!result.success) {
-      const skillDirPath = (0, import_node_path50.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
+      const skillDirPath = (0, import_node_path51.join)(loaded.baseDir, loaded.relativeDirPath, loaded.dirName);
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path50.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${(0, import_node_path51.join)(skillDirPath, SKILL_FILE_NAME)}: ${formatError(result.error)}`
       );
     }
     return new _ClaudecodeSkill({
@@ -5162,36 +5257,6 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   }
 };
 
-// src/features/skills/geminicli-skill.ts
-var import_node_path51 = 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_path51.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"
-    });
-  }
-};
-
 // src/features/skills/skills-processor.ts
 var skillsProcessorToolTargetTuple = [
   "agentsmd",
@@ -6124,6 +6189,12 @@ var RulesyncRuleFrontmatterSchema = import_mini28.z.object({
     import_mini28.z.object({
       excludeAgent: import_mini28.z.optional(import_mini28.z.union([import_mini28.z.literal("code-review"), import_mini28.z.literal("coding-agent")]))
     })
+  ),
+  antigravity: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      trigger: import_mini28.z.optional(import_mini28.z.string()),
+      globs: import_mini28.z.optional(import_mini28.z.array(import_mini28.z.string()))
+    })
   )
 });
 var RulesyncRule = class _RulesyncRule extends RulesyncFile {
@@ -6493,7 +6564,176 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path67 = require("path");
+var import_mini29 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini29.z.looseObject({
+  trigger: import_mini29.z.optional(
+    import_mini29.z.union([
+      import_mini29.z.literal("always_on"),
+      import_mini29.z.literal("glob"),
+      import_mini29.z.literal("manual"),
+      import_mini29.z.literal("model_decision"),
+      import_mini29.z.string()
+      // accepts any string for forward compatibility
+    ])
+  ),
+  globs: import_mini29.z.optional(import_mini29.z.string()),
+  description: import_mini29.z.optional(import_mini29.z.string())
+});
+function parseGlobsString(globs) {
+  if (!globs) {
+    return [];
+  }
+  if (Array.isArray(globs)) {
+    return globs;
+  }
+  if (globs.trim() === "") {
+    return [];
+  }
+  return globs.split(",").map((g) => g.trim());
+}
+function stringifyGlobs(globs) {
+  if (!globs || globs.length === 0) {
+    return void 0;
+  }
+  return globs.join(",");
+}
+function normalizeStoredAntigravity(stored) {
+  if (!stored) {
+    return void 0;
+  }
+  const { globs, ...rest } = stored;
+  return {
+    ...rest,
+    globs: Array.isArray(globs) ? stringifyGlobs(globs) : globs
+  };
+}
+var globStrategy = {
+  canHandle: (trigger) => trigger === "glob",
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => {
+    const effectiveGlobsArray = normalized?.globs ? parseGlobsString(normalized.globs) : rulesyncFrontmatter.globs ?? [];
+    return {
+      ...normalized,
+      trigger: "glob",
+      globs: stringifyGlobs(effectiveGlobsArray)
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: parseGlobsString(frontmatter.globs),
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var manualStrategy = {
+  canHandle: (trigger) => trigger === "manual",
+  generateFrontmatter: (normalized) => ({
+    ...normalized,
+    trigger: "manual"
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: [],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var alwaysOnStrategy = {
+  canHandle: (trigger) => trigger === "always_on",
+  generateFrontmatter: (normalized) => ({
+    ...normalized,
+    trigger: "always_on"
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var modelDecisionStrategy = {
+  canHandle: (trigger) => trigger === "model_decision",
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => ({
+    ...normalized,
+    trigger: "model_decision",
+    description: rulesyncFrontmatter.description
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: [],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var unknownStrategy = {
+  canHandle: (trigger) => trigger !== void 0,
+  generateFrontmatter: (normalized) => {
+    const trigger = typeof normalized?.trigger === "string" ? normalized.trigger : "manual";
+    return {
+      ...normalized,
+      trigger
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var inferenceStrategy = {
+  canHandle: (trigger) => trigger === void 0,
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => {
+    const effectiveGlobsArray = normalized?.globs ? parseGlobsString(normalized.globs) : rulesyncFrontmatter.globs ?? [];
+    if (effectiveGlobsArray.length > 0 && !effectiveGlobsArray.includes("**/*") && !effectiveGlobsArray.includes("*")) {
+      return {
+        ...normalized,
+        trigger: "glob",
+        globs: stringifyGlobs(effectiveGlobsArray)
+      };
+    }
+    return {
+      ...normalized,
+      trigger: "always_on"
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var STRATEGIES = [
+  globStrategy,
+  manualStrategy,
+  alwaysOnStrategy,
+  modelDecisionStrategy,
+  unknownStrategy,
+  inferenceStrategy
+];
 var AntigravityRule = class _AntigravityRule extends ToolRule {
+  frontmatter;
+  body;
+  /**
+   * Creates an AntigravityRule instance.
+   *
+   * @param params - Rule parameters including frontmatter and body
+   * @param params.frontmatter - Antigravity-specific frontmatter configuration
+   * @param params.body - The markdown body content (without frontmatter)
+   *
+   * Note: Files without frontmatter will default to always_on trigger during fromFile().
+   */
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = AntigravityRuleFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${(0, import_node_path67.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+        );
+      }
+    }
+    super({
+      ...rest,
+      // Ensure fileContent includes frontmatter when constructed directly
+      fileContent: stringifyFrontmatter(body, frontmatter)
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
   static getSettablePaths() {
     return {
       nonRoot: {
@@ -6506,36 +6746,121 @@ var AntigravityRule = class _AntigravityRule extends ToolRule {
     relativeFilePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(
-      (0, import_node_path67.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+    const filePath = (0, import_node_path67.join)(
+      baseDir,
+      this.getSettablePaths().nonRoot.relativeDirPath,
+      relativeFilePath
     );
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body } = parseFrontmatter(fileContent);
+    let parsedFrontmatter;
+    if (validate) {
+      const result = AntigravityRuleFrontmatterSchema.safeParse(frontmatter);
+      if (result.success) {
+        parsedFrontmatter = result.data;
+      } else {
+        throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+      }
+    } else {
+      parsedFrontmatter = frontmatter;
+    }
     return new _AntigravityRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
       relativeFilePath,
-      fileContent,
+      body,
+      frontmatter: parsedFrontmatter,
       validate,
       root: false
     });
   }
+  /**
+   * Converts a RulesyncRule to an AntigravityRule.
+   *
+   * Trigger inference:
+   * - If antigravity.trigger is set, it's preserved
+   * - If specific globs are set, infers "glob" trigger
+   * - Otherwise, infers "always_on" trigger
+   */
   static fromRulesyncRule({
     baseDir = process.cwd(),
     rulesyncRule,
     validate = true
   }) {
-    return new _AntigravityRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
+    const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
+    const storedAntigravity = rulesyncFrontmatter.antigravity;
+    const normalized = normalizeStoredAntigravity(storedAntigravity);
+    const storedTrigger = storedAntigravity?.trigger;
+    const strategy = STRATEGIES.find((s) => s.canHandle(storedTrigger));
+    if (!strategy) {
+      throw new Error(`No strategy found for trigger: ${storedTrigger}`);
+    }
+    const frontmatter = strategy.generateFrontmatter(normalized, rulesyncFrontmatter);
+    const paths = this.getSettablePaths();
+    const kebabCaseFilename = toKebabCaseFilename(rulesyncRule.getRelativeFilePath());
+    return new _AntigravityRule({
+      baseDir,
+      relativeDirPath: paths.nonRoot.relativeDirPath,
+      relativeFilePath: kebabCaseFilename,
+      frontmatter,
+      body: rulesyncRule.getBody(),
+      validate,
+      root: false
+    });
   }
+  /**
+   * Converts this AntigravityRule to a RulesyncRule.
+   *
+   * The Antigravity configuration is preserved in the RulesyncRule's
+   * frontmatter.antigravity field for round-trip compatibility.
+   *
+   * Note: All Antigravity rules are treated as non-root (root: false),
+   * as they are all placed in the .agent/rules directory.
+   *
+   * @returns RulesyncRule instance with Antigravity config preserved
+   */
   toRulesyncRule() {
-    return this.toRulesyncRuleDefault();
+    const strategy = STRATEGIES.find((s) => s.canHandle(this.frontmatter.trigger));
+    let rulesyncData = {
+      globs: [],
+      description: "",
+      antigravity: this.frontmatter
+    };
+    if (strategy) {
+      rulesyncData = strategy.exportRulesyncData(this.frontmatter);
+    }
+    const antigravityForRulesync = {
+      ...rulesyncData.antigravity,
+      globs: this.frontmatter.globs ? parseGlobsString(this.frontmatter.globs) : void 0
+    };
+    return new RulesyncRule({
+      baseDir: process.cwd(),
+      relativeDirPath: RulesyncRule.getSettablePaths().recommended.relativeDirPath,
+      relativeFilePath: this.getRelativeFilePath(),
+      frontmatter: {
+        root: false,
+        targets: ["*"],
+        ...rulesyncData,
+        antigravity: antigravityForRulesync
+      },
+      // When converting back, we only want the body content
+      body: this.body
+    });
+  }
+  getBody() {
+    return this.body;
+  }
+  // Helper to access raw file content including frontmatter is `this.fileContent` (from ToolFile)
+  // But we might want `body` only for some operations?
+  // ToolFile.getFileContent() returns the whole string.
+  getFrontmatter() {
+    return this.frontmatter;
   }
   validate() {
+    const result = AntigravityRuleFrontmatterSchema.safeParse(this.frontmatter);
+    if (!result.success) {
+      return { success: false, error: new Error(formatError(result.error)) };
+    }
     return { success: true, error: null };
   }
   static isTargetedByRulesyncRule(rulesyncRule) {
@@ -6769,9 +7094,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path71 = require("path");
-var import_mini29 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini29.z.object({
-  paths: import_mini29.z.optional(import_mini29.z.string())
+var import_mini30 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini30.z.object({
+  paths: import_mini30.z.optional(import_mini30.z.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -6961,9 +7286,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path72 = require("path");
-var import_mini30 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini30.z.object({
-  description: import_mini30.z.string()
+var import_mini31 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini31.z.object({
+  description: import_mini31.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -7110,11 +7435,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path74 = require("path");
-var import_mini31 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini31.z.object({
-  description: import_mini31.z.optional(import_mini31.z.string()),
-  applyTo: import_mini31.z.optional(import_mini31.z.string()),
-  excludeAgent: import_mini31.z.optional(import_mini31.z.union([import_mini31.z.literal("code-review"), import_mini31.z.literal("coding-agent")]))
+var import_mini32 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini32.z.object({
+  description: import_mini32.z.optional(import_mini32.z.string()),
+  applyTo: import_mini32.z.optional(import_mini32.z.string()),
+  excludeAgent: import_mini32.z.optional(import_mini32.z.union([import_mini32.z.literal("code-review"), import_mini32.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -7282,11 +7607,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path75 = require("path");
-var import_mini32 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini32.z.object({
-  description: import_mini32.z.optional(import_mini32.z.string()),
-  globs: import_mini32.z.optional(import_mini32.z.string()),
-  alwaysApply: import_mini32.z.optional(import_mini32.z.boolean())
+var import_mini33 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini33.z.object({
+  description: import_mini33.z.optional(import_mini33.z.string()),
+  globs: import_mini33.z.optional(import_mini33.z.string()),
+  alwaysApply: import_mini33.z.optional(import_mini33.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -8004,34 +8329,197 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini33.z.enum(rulesProcessorToolTargets);
-var rulesProcessorToolTargetsGlobal = [
-  "claudecode",
-  "claudecode-legacy",
-  "codexcli",
-  "geminicli"
-];
+var RulesProcessorToolTargetSchema = import_mini34.z.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
-  ["agentsmd", { class: AgentsMdRule, meta: { extension: "md" } }],
-  ["amazonqcli", { class: AmazonQCliRule, meta: { extension: "md" } }],
-  ["antigravity", { class: AntigravityRule, meta: { extension: "md" } }],
-  ["augmentcode", { class: AugmentcodeRule, meta: { extension: "md" } }],
-  ["augmentcode-legacy", { class: AugmentcodeLegacyRule, meta: { extension: "md" } }],
-  ["claudecode", { class: ClaudecodeRule, meta: { extension: "md" } }],
-  ["claudecode-legacy", { class: ClaudecodeLegacyRule, meta: { extension: "md" } }],
-  ["cline", { class: ClineRule, meta: { extension: "md" } }],
-  ["codexcli", { class: CodexcliRule, meta: { extension: "md" } }],
-  ["copilot", { class: CopilotRule, meta: { extension: "md" } }],
-  ["cursor", { class: CursorRule, meta: { extension: "mdc" } }],
-  ["geminicli", { class: GeminiCliRule, meta: { extension: "md" } }],
-  ["junie", { class: JunieRule, meta: { extension: "md" } }],
-  ["kiro", { class: KiroRule, meta: { extension: "md" } }],
-  ["opencode", { class: OpenCodeRule, meta: { extension: "md" } }],
-  ["qwencode", { class: QwencodeRule, meta: { extension: "md" } }],
-  ["roo", { class: RooRule, meta: { extension: "md" } }],
-  ["warp", { class: WarpRule, meta: { extension: "md" } }],
-  ["windsurf", { class: WindsurfRule, meta: { extension: "md" } }]
+  [
+    "agentsmd",
+    {
+      class: AgentsMdRule,
+      meta: {
+        extension: "md",
+        supportsGlobal: false,
+        ruleDiscoveryMode: "toon",
+        additionalConventions: {
+          commands: { commandClass: AgentsmdCommand },
+          subagents: { subagentClass: AgentsmdSubagent },
+          skills: { skillClass: AgentsmdSkill }
+        }
+      }
+    }
+  ],
+  [
+    "amazonqcli",
+    {
+      class: AmazonQCliRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "auto" }
+    }
+  ],
+  [
+    "antigravity",
+    {
+      class: AntigravityRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "auto" }
+    }
+  ],
+  [
+    "augmentcode",
+    {
+      class: AugmentcodeRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "auto" }
+    }
+  ],
+  [
+    "augmentcode-legacy",
+    {
+      class: AugmentcodeLegacyRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "toon" }
+    }
+  ],
+  [
+    "claudecode",
+    {
+      class: ClaudecodeRule,
+      meta: { extension: "md", supportsGlobal: true, ruleDiscoveryMode: "auto" }
+    }
+  ],
+  [
+    "claudecode-legacy",
+    {
+      class: ClaudecodeLegacyRule,
+      meta: { extension: "md", supportsGlobal: true, ruleDiscoveryMode: "claudecode-legacy" }
+    }
+  ],
+  [
+    "cline",
+    {
+      class: ClineRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "auto" }
+    }
+  ],
+  [
+    "codexcli",
+    {
+      class: CodexcliRule,
+      meta: {
+        extension: "md",
+        supportsGlobal: true,
+        ruleDiscoveryMode: "toon",
+        additionalConventions: {
+          subagents: { subagentClass: CodexCliSubagent },
+          skills: { skillClass: CodexCliSkill, globalOnly: true }
+        }
+      }
+    }
+  ],
+  [
+    "copilot",
+    {
+      class: CopilotRule,
+      meta: {
+        extension: "md",
+        supportsGlobal: false,
+        ruleDiscoveryMode: "auto",
+        additionalConventions: {
+          commands: { commandClass: CopilotCommand },
+          subagents: { subagentClass: CopilotSubagent },
+          skills: { skillClass: CopilotSkill }
+        }
+      }
+    }
+  ],
+  [
+    "cursor",
+    {
+      class: CursorRule,
+      meta: {
+        extension: "mdc",
+        supportsGlobal: false,
+        ruleDiscoveryMode: "auto",
+        additionalConventions: {
+          commands: { commandClass: CursorCommand },
+          subagents: { subagentClass: CursorSubagent },
+          skills: { skillClass: CursorSkill }
+        },
+        createsSeparateConventionsRule: true
+      }
+    }
+  ],
+  [
+    "geminicli",
+    {
+      class: GeminiCliRule,
+      meta: {
+        extension: "md",
+        supportsGlobal: true,
+        ruleDiscoveryMode: "toon",
+        additionalConventions: {
+          commands: { commandClass: GeminiCliCommand },
+          subagents: { subagentClass: GeminiCliSubagent },
+          skills: { skillClass: GeminiCliSkill }
+        }
+      }
+    }
+  ],
+  [
+    "junie",
+    {
+      class: JunieRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "toon" }
+    }
+  ],
+  [
+    "kiro",
+    {
+      class: KiroRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "toon" }
+    }
+  ],
+  [
+    "opencode",
+    {
+      class: OpenCodeRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "toon" }
+    }
+  ],
+  [
+    "qwencode",
+    {
+      class: QwencodeRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "toon" }
+    }
+  ],
+  [
+    "roo",
+    {
+      class: RooRule,
+      meta: {
+        extension: "md",
+        supportsGlobal: false,
+        ruleDiscoveryMode: "auto",
+        additionalConventions: {
+          commands: { commandClass: RooCommand },
+          subagents: { subagentClass: RooSubagent }
+        },
+        createsSeparateConventionsRule: true
+      }
+    }
+  ],
+  [
+    "warp",
+    {
+      class: WarpRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "toon" }
+    }
+  ],
+  [
+    "windsurf",
+    {
+      class: WindsurfRule,
+      meta: { extension: "md", supportsGlobal: false, ruleDiscoveryMode: "auto" }
+    }
+  ]
 ]);
+var rulesProcessorToolTargetsGlobal = Array.from(toolRuleFactories.entries()).filter(([_, factory]) => factory.meta.supportsGlobal).map(([target]) => target);
 var defaultGetFactory6 = (target) => {
   const factory = toolRuleFactories.get(target);
   if (!factory) {
@@ -8046,6 +8534,7 @@ var RulesProcessor = class extends FeatureProcessor {
   simulateSkills;
   global;
   getFactory;
+  skills;
   constructor({
     baseDir = process.cwd(),
     toolTarget,
@@ -8053,7 +8542,8 @@ var RulesProcessor = class extends FeatureProcessor {
     simulateSubagents = false,
     simulateSkills = false,
     global = false,
-    getFactory = defaultGetFactory6
+    getFactory = defaultGetFactory6,
+    skills
   }) {
     super({ baseDir });
     const result = RulesProcessorToolTargetSchema.safeParse(toolTarget);
@@ -8068,12 +8558,14 @@ var RulesProcessor = class extends FeatureProcessor {
     this.simulateSubagents = simulateSubagents;
     this.simulateSkills = simulateSkills;
     this.getFactory = getFactory;
+    this.skills = skills;
   }
   async convertRulesyncFilesToToolFiles(rulesyncFiles) {
     const rulesyncRules = rulesyncFiles.filter(
       (file) => file instanceof RulesyncRule
     );
     const factory = this.getFactory(this.toolTarget);
+    const { meta } = factory;
     const toolRules = rulesyncRules.map((rulesyncRule) => {
       if (!factory.class.isTargetedByRulesyncRule(rulesyncRule)) {
         return null;
@@ -8086,153 +8578,105 @@ var RulesProcessor = class extends FeatureProcessor {
       });
     }).filter((rule) => rule !== null);
     const isSimulated = this.simulateCommands || this.simulateSubagents || this.simulateSkills;
-    if (isSimulated && this.toolTarget === "cursor") {
-      toolRules.push(
-        new CursorRule({
-          baseDir: this.baseDir,
-          frontmatter: {
-            alwaysApply: true
-          },
-          body: this.generateAdditionalConventionsSection({
-            commands: { relativeDirPath: CursorCommand.getSettablePaths().relativeDirPath },
-            subagents: {
-              relativeDirPath: CursorSubagent.getSettablePaths().relativeDirPath
-            },
-            skills: {
-              relativeDirPath: CursorSkill.getSettablePaths().relativeDirPath
-            }
-          }),
-          relativeDirPath: CursorRule.getSettablePaths().nonRoot.relativeDirPath,
-          relativeFilePath: "additional-conventions.mdc",
-          validate: true
-        })
-      );
-    }
-    if (isSimulated && this.toolTarget === "roo") {
-      toolRules.push(
-        new RooRule({
-          baseDir: this.baseDir,
-          relativeDirPath: RooRule.getSettablePaths().nonRoot.relativeDirPath,
-          relativeFilePath: "additional-conventions.md",
-          fileContent: this.generateAdditionalConventionsSection({
-            commands: { relativeDirPath: RooCommand.getSettablePaths().relativeDirPath },
-            subagents: {
-              relativeDirPath: RooSubagent.getSettablePaths().relativeDirPath
-            }
-          }),
-          validate: true
-        })
-      );
+    if (isSimulated && meta.createsSeparateConventionsRule && meta.additionalConventions) {
+      const conventionsContent = this.generateAdditionalConventionsSectionFromMeta(meta);
+      const settablePaths = factory.class.getSettablePaths();
+      const nonRootPath = "nonRoot" in settablePaths ? settablePaths.nonRoot : null;
+      if (nonRootPath) {
+        toolRules.push(
+          factory.class.fromRulesyncRule({
+            baseDir: this.baseDir,
+            rulesyncRule: new RulesyncRule({
+              baseDir: this.baseDir,
+              relativeDirPath: nonRootPath.relativeDirPath,
+              relativeFilePath: "additional-conventions.md",
+              frontmatter: {
+                root: false,
+                targets: [this.toolTarget]
+              },
+              body: conventionsContent
+            }),
+            validate: true,
+            global: this.global
+          })
+        );
+      }
     }
     const rootRuleIndex = toolRules.findIndex((rule) => rule.isRoot());
     if (rootRuleIndex === -1) {
       return toolRules;
     }
-    switch (this.toolTarget) {
-      case "agentsmd": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + this.generateAdditionalConventionsSection({
-            commands: { relativeDirPath: AgentsmdCommand.getSettablePaths().relativeDirPath },
-            subagents: {
-              relativeDirPath: AgentsmdSubagent.getSettablePaths().relativeDirPath
-            }
-          }) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "augmentcode-legacy": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "claudecode": {
-        return toolRules;
-      }
-      case "claudecode-legacy": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateReferencesSection(toolRules) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "codexcli": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + this.generateAdditionalConventionsSection({
-            subagents: {
-              relativeDirPath: CodexCliSubagent.getSettablePaths().relativeDirPath
-            },
-            // Codex CLI skills are only supported in global mode
-            ...this.global && {
-              skills: {
-                relativeDirPath: CodexCliSkill.getSettablePaths({ global: this.global }).relativeDirPath
-              }
-            }
-          }) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "copilot": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateAdditionalConventionsSection({
-            commands: { relativeDirPath: CopilotCommand.getSettablePaths().relativeDirPath },
-            subagents: {
-              relativeDirPath: CopilotSubagent.getSettablePaths().relativeDirPath
-            },
-            skills: {
-              relativeDirPath: CopilotSkill.getSettablePaths().relativeDirPath
-            }
-          }) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "geminicli": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + this.generateAdditionalConventionsSection({
-            commands: { relativeDirPath: GeminiCliCommand.getSettablePaths().relativeDirPath },
-            subagents: {
-              relativeDirPath: GeminiCliSubagent.getSettablePaths().relativeDirPath
-            }
-          }) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "kiro": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "opencode": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "qwencode": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
-      case "warp": {
-        const rootRule = toolRules[rootRuleIndex];
-        rootRule?.setFileContent(
-          this.generateToonReferencesSection(toolRules) + rootRule.getFileContent()
-        );
-        return toolRules;
-      }
+    const rootRule = toolRules[rootRuleIndex];
+    if (!rootRule) {
+      return toolRules;
+    }
+    const referenceSection = this.generateReferenceSectionFromMeta(meta, toolRules);
+    const conventionsSection = !meta.createsSeparateConventionsRule && meta.additionalConventions ? this.generateAdditionalConventionsSectionFromMeta(meta) : "";
+    const newContent = referenceSection + conventionsSection + rootRule.getFileContent();
+    rootRule.setFileContent(newContent);
+    return toolRules;
+  }
+  buildSkillList(skillClass) {
+    if (!this.skills) return [];
+    const toolRelativeDirPath = skillClass.getSettablePaths({
+      global: this.global
+    }).relativeDirPath;
+    return this.skills.filter((skill) => skillClass.isTargetedByRulesyncSkill(skill)).map((skill) => {
+      const frontmatter = skill.getFrontmatter();
+      const relativePath = (0, import_node_path84.join)(toolRelativeDirPath, skill.getDirName(), SKILL_FILE_NAME);
+      return {
+        name: frontmatter.name,
+        description: frontmatter.description,
+        path: relativePath
+      };
+    });
+  }
+  /**
+   * Generate reference section based on meta configuration.
+   */
+  generateReferenceSectionFromMeta(meta, toolRules) {
+    switch (meta.ruleDiscoveryMode) {
+      case "toon":
+        return this.generateToonReferencesSection(toolRules);
+      case "claudecode-legacy":
+        return this.generateReferencesSection(toolRules);
+      case "auto":
       default:
-        return toolRules;
+        return "";
+    }
+  }
+  /**
+   * Generate additional conventions section based on meta configuration.
+   */
+  generateAdditionalConventionsSectionFromMeta(meta) {
+    const { additionalConventions } = meta;
+    if (!additionalConventions) {
+      return "";
+    }
+    const conventions = {};
+    if (additionalConventions.commands) {
+      const { commandClass } = additionalConventions.commands;
+      const relativeDirPath = commandClass.getSettablePaths({
+        global: this.global
+      }).relativeDirPath;
+      conventions.commands = { relativeDirPath };
     }
+    if (additionalConventions.subagents) {
+      const { subagentClass } = additionalConventions.subagents;
+      const relativeDirPath = subagentClass.getSettablePaths({
+        global: this.global
+      }).relativeDirPath;
+      conventions.subagents = { relativeDirPath };
+    }
+    if (additionalConventions.skills) {
+      const { skillClass, globalOnly } = additionalConventions.skills;
+      if (!globalOnly || this.global) {
+        conventions.skills = {
+          skillList: this.buildSkillList(skillClass)
+        };
+      }
+    }
+    return this.generateAdditionalConventionsSection(conventions);
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
     const toolRules = toolFiles.filter((file) => file instanceof ToolRule);
@@ -8417,15 +8861,7 @@ Simulated subagents are specialized AI assistants that can be invoked to handle
 When users call a simulated subagent, it will look for the corresponding markdown file, \`${(0, import_node_path84.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "{subagent}.md")}\`, and execute its contents as the block of operations.
 
 For example, if the user instructs \`Call planner subagent to plan the refactoring\`, you have to look for the markdown file, \`${(0, import_node_path84.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "planner.md")}\`, and execute its contents as the block of operations.` : "";
-    const skillsSection = skills ? `## Simulated Skills
-
-Simulated skills are specialized capabilities that can be invoked to handle specific types of tasks.
-
-When users invoke a simulated skill, look for the corresponding SKILL.md file in \`${(0, import_node_path84.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "{skill}/SKILL.md")}\` and execute its contents as the block of operations.
-
-For example, if the user instructs \`Use the skill example-skill to achieve something\`, look for \`${(0, import_node_path84.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "example-skill/SKILL.md")}\` and execute its contents.
-
-Additionally, you should proactively consider using available skills when they would help accomplish a task more effectively, even if the user doesn't explicitly request them.` : "";
+    const skillsSection = skills ? this.generateSkillsSection(skills) : "";
     const result = [
       overview,
       ...this.simulateCommands && CommandsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [commandsSection] : [],
@@ -8434,6 +8870,21 @@ Additionally, you should proactively consider using available skills when they w
     ].join("\n\n") + "\n\n";
     return result;
   }
+  generateSkillsSection(skills) {
+    if (!skills.skillList || skills.skillList.length === 0) {
+      return "";
+    }
+    const skillListWithAtPrefix = skills.skillList.map((skill) => ({
+      ...skill,
+      path: `@${skill.path}`
+    }));
+    const toonContent = (0, import_toon.encode)({ skillList: skillListWithAtPrefix });
+    return `## Simulated Skills
+
+Simulated skills are specialized capabilities that can be invoked to handle specific types of tasks. When you determine that a skill would be helpful for the current task, read the corresponding SKILL.md file and execute its instructions.
+
+${toonContent}`;
+  }
 };
 
 // src/cli/commands/generate.ts
@@ -8446,13 +8897,15 @@ async function generateCommand(options) {
     process.exit(1);
   }
   logger.info(`Base directories: ${config.getBaseDirs().join(", ")}`);
-  const totalRulesOutputs = await generateRules(config);
   const totalIgnoreOutputs = await generateIgnore(config);
   const totalMcpOutputs = await generateMcp(config);
   const totalCommandOutputs = await generateCommands(config);
   const totalSubagentOutputs = await generateSubagents(config);
-  const totalSkillOutputs = await generateSkills(config);
-  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs + totalSkillOutputs;
+  const skillsResult = await generateSkills(config);
+  const totalRulesOutputs = await generateRules(config, {
+    skills: skillsResult.skills
+  });
+  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs + skillsResult.totalOutputs;
   if (totalGenerated === 0) {
     const enabledFeatures = config.getFeatures().join(", ");
     logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
@@ -8465,18 +8918,18 @@ async function generateCommand(options) {
     if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP files`);
     if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
     if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
-    if (totalSkillOutputs > 0) parts.push(`${totalSkillOutputs} skills`);
+    if (skillsResult.totalOutputs > 0) parts.push(`${skillsResult.totalOutputs} skills`);
     logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
 }
-async function generateRules(config) {
+async function generateRules(config, options) {
   if (!config.getFeatures().includes("rules")) {
     logger.debug("Skipping rule generation (not in --features)");
     return 0;
   }
   let totalRulesOutputs = 0;
   logger.info("Generating rule files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     RulesProcessor.getToolTargets({ global: config.getGlobal() })
   );
@@ -8488,7 +8941,8 @@ async function generateRules(config) {
         global: config.getGlobal(),
         simulateCommands: config.getSimulateCommands(),
         simulateSubagents: config.getSimulateSubagents(),
-        simulateSkills: config.getSimulateSkills()
+        simulateSkills: config.getSimulateSkills(),
+        skills: options?.skills
       });
       if (config.getDelete()) {
         const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
@@ -8517,7 +8971,7 @@ async function generateIgnore(config) {
   }
   let totalIgnoreOutputs = 0;
   logger.info("Generating ignore files...");
-  for (const toolTarget of (0, import_es_toolkit2.intersection)(config.getTargets(), IgnoreProcessor.getToolTargets())) {
+  for (const toolTarget of (0, import_es_toolkit3.intersection)(config.getTargets(), IgnoreProcessor.getToolTargets())) {
     for (const baseDir of config.getBaseDirs()) {
       try {
         const processor = new IgnoreProcessor({
@@ -8556,7 +9010,7 @@ async function generateMcp(config) {
   if (config.getModularMcp()) {
     logger.info("\u2139\uFE0F  Modular MCP support is experimental.");
   }
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     McpProcessor.getToolTargets({ global: config.getGlobal() })
   );
@@ -8588,7 +9042,7 @@ async function generateCommands(config) {
   }
   let totalCommandOutputs = 0;
   logger.info("Generating command files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     CommandsProcessor.getToolTargets({
       global: config.getGlobal(),
@@ -8622,7 +9076,7 @@ async function generateSubagents(config) {
   }
   let totalSubagentOutputs = 0;
   logger.info("Generating subagent files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     SubagentsProcessor.getToolTargets({
       global: config.getGlobal(),
@@ -8652,11 +9106,12 @@ async function generateSubagents(config) {
 async function generateSkills(config) {
   if (!config.getFeatures().includes("skills")) {
     logger.debug("Skipping skill generation (not in --features)");
-    return 0;
+    return { totalOutputs: 0, skills: [] };
   }
   let totalSkillOutputs = 0;
+  const allSkills = [];
   logger.info("Generating skill files...");
-  const toolTargets = (0, import_es_toolkit2.intersection)(
+  const toolTargets = (0, import_es_toolkit3.intersection)(
     config.getTargets(),
     SkillsProcessor.getToolTargets({
       global: config.getGlobal(),
@@ -8675,13 +9130,18 @@ async function generateSkills(config) {
         await processor.removeAiDirs(oldToolDirs);
       }
       const rulesyncDirs = await processor.loadRulesyncDirs();
+      for (const rulesyncDir of rulesyncDirs) {
+        if (rulesyncDir instanceof RulesyncSkill) {
+          allSkills.push(rulesyncDir);
+        }
+      }
       const toolDirs = await processor.convertRulesyncDirsToToolDirs(rulesyncDirs);
       const writtenCount = await processor.writeAiDirs(toolDirs);
       totalSkillOutputs += writtenCount;
       logger.success(`Generated ${writtenCount} ${toolTarget} skill(s) in ${baseDir}`);
     }
   }
-  return totalSkillOutputs;
+  return { totalOutputs: totalSkillOutputs, skills: allSkills };
 }
 
 // src/cli/commands/gitignore.ts
@@ -9218,7 +9678,7 @@ var import_fastmcp = require("fastmcp");
 
 // src/mcp/commands.ts
 var import_node_path87 = require("path");
-var import_mini34 = require("zod/mini");
+var import_mini35 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -9337,17 +9797,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini34.z.object({}),
-  getCommand: import_mini34.z.object({
-    relativePathFromCwd: import_mini34.z.string()
+  listCommands: import_mini35.z.object({}),
+  getCommand: import_mini35.z.object({
+    relativePathFromCwd: import_mini35.z.string()
   }),
-  putCommand: import_mini34.z.object({
-    relativePathFromCwd: import_mini34.z.string(),
+  putCommand: import_mini35.z.object({
+    relativePathFromCwd: import_mini35.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini34.z.string()
+    body: import_mini35.z.string()
   }),
-  deleteCommand: import_mini34.z.object({
-    relativePathFromCwd: import_mini34.z.string()
+  deleteCommand: import_mini35.z.object({
+    relativePathFromCwd: import_mini35.z.string()
   })
 };
 var commandTools = {
@@ -9396,7 +9856,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 var import_node_path88 = require("path");
-var import_mini35 = require("zod/mini");
+var import_mini36 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path88.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -9453,11 +9913,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini35.z.object({}),
-  putIgnoreFile: import_mini35.z.object({
-    content: import_mini35.z.string()
+  getIgnoreFile: import_mini36.z.object({}),
+  putIgnoreFile: import_mini36.z.object({
+    content: import_mini36.z.string()
   }),
-  deleteIgnoreFile: import_mini35.z.object({})
+  deleteIgnoreFile: import_mini36.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -9491,7 +9951,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 var import_node_path89 = require("path");
-var import_mini36 = require("zod/mini");
+var import_mini37 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -9581,11 +10041,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini36.z.object({}),
-  putMcpFile: import_mini36.z.object({
-    content: import_mini36.z.string()
+  getMcpFile: import_mini37.z.object({}),
+  putMcpFile: import_mini37.z.object({
+    content: import_mini37.z.string()
   }),
-  deleteMcpFile: import_mini36.z.object({})
+  deleteMcpFile: import_mini37.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -9619,7 +10079,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 var import_node_path90 = require("path");
-var import_mini37 = require("zod/mini");
+var import_mini38 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -9738,17 +10198,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini37.z.object({}),
-  getRule: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string()
+  listRules: import_mini38.z.object({}),
+  getRule: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string()
   }),
-  putRule: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string(),
+  putRule: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini37.z.string()
+    body: import_mini38.z.string()
   }),
-  deleteRule: import_mini37.z.object({
-    relativePathFromCwd: import_mini37.z.string()
+  deleteRule: import_mini38.z.object({
+    relativePathFromCwd: import_mini38.z.string()
   })
 };
 var ruleTools = {
@@ -9797,7 +10257,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path91 = require("path");
-var import_mini38 = require("zod/mini");
+var import_mini39 = require("zod/mini");
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -9965,23 +10425,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini38.z.object({
-  name: import_mini38.z.string(),
-  body: import_mini38.z.string()
+var McpSkillFileSchema = import_mini39.z.object({
+  name: import_mini39.z.string(),
+  body: import_mini39.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini38.z.object({}),
-  getSkill: import_mini38.z.object({
-    relativeDirPathFromCwd: import_mini38.z.string()
+  listSkills: import_mini39.z.object({}),
+  getSkill: import_mini39.z.object({
+    relativeDirPathFromCwd: import_mini39.z.string()
   }),
-  putSkill: import_mini38.z.object({
-    relativeDirPathFromCwd: import_mini38.z.string(),
+  putSkill: import_mini39.z.object({
+    relativeDirPathFromCwd: import_mini39.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini38.z.string(),
-    otherFiles: import_mini38.z.optional(import_mini38.z.array(McpSkillFileSchema))
+    body: import_mini39.z.string(),
+    otherFiles: import_mini39.z.optional(import_mini39.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini38.z.object({
-    relativeDirPathFromCwd: import_mini38.z.string()
+  deleteSkill: import_mini39.z.object({
+    relativeDirPathFromCwd: import_mini39.z.string()
   })
 };
 var skillTools = {
@@ -10031,7 +10491,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path92 = require("path");
-var import_mini39 = require("zod/mini");
+var import_mini40 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -10155,17 +10615,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini39.z.object({}),
-  getSubagent: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string()
+  listSubagents: import_mini40.z.object({}),
+  getSubagent: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string()
   }),
-  putSubagent: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string(),
+  putSubagent: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini39.z.string()
+    body: import_mini40.z.string()
   }),
-  deleteSubagent: import_mini39.z.object({
-    relativePathFromCwd: import_mini39.z.string()
+  deleteSubagent: import_mini40.z.object({
+    relativePathFromCwd: import_mini40.z.string()
   })
 };
 var subagentTools = {
@@ -10249,7 +10709,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.32.0";
+var getVersion = () => "3.34.0";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();