rulesync 3.23.6 → 3.25.0

package/dist/index.js

@@ -8,7 +8,7 @@ var ANNOUNCEMENT = "".trim();
 
 // src/types/features.ts
 import { z } from "zod/mini";
-var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
+var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands", "skills"];
 var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 var FeatureSchema = z.enum(ALL_FEATURES);
 var FeaturesSchema = z.array(FeatureSchema);
@@ -137,6 +137,10 @@ async function readFileContent(filepath) {
   logger.debug(`Reading file: ${filepath}`);
   return readFile(filepath, "utf-8");
 }
+async function readFileBuffer(filepath) {
+  logger.debug(`Reading file buffer: ${filepath}`);
+  return readFile(filepath);
+}
 function addTrailingNewline(content) {
   if (!content) {
     return "\n";
@@ -164,11 +168,32 @@ async function listDirectoryFiles(dir) {
   }
 }
 async function findFilesByGlobs(globs, options = {}) {
+  const { type = "all" } = options;
   const items = globSync(globs, { withFileTypes: true });
-  if (!options.fileOnly) {
-    return items.map((item) => join(item.parentPath, item.name));
+  switch (type) {
+    case "file":
+      return items.filter((item) => item.isFile()).map((item) => join(item.parentPath, item.name));
+    case "dir":
+      return items.filter((item) => item.isDirectory()).map((item) => join(item.parentPath, item.name));
+    case "all":
+      return items.map((item) => join(item.parentPath, item.name));
+    default:
+      throw new Error(`Invalid type: ${type}`);
+  }
+}
+async function removeDirectory(dirPath) {
+  const dangerousPaths = [".", "/", "~", "src", "node_modules"];
+  if (dangerousPaths.includes(dirPath) || dirPath === "") {
+    logger.warn(`Skipping deletion of dangerous path: ${dirPath}`);
+    return;
+  }
+  try {
+    if (await fileExists(dirPath)) {
+      await rm(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    logger.warn(`Failed to remove directory ${dirPath}:`, error);
   }
-  return items.filter((item) => item.isFile()).map((item) => join(item.parentPath, item.name));
 }
 async function removeFile(filepath) {
   logger.debug(`Removing file: ${filepath}`);
@@ -231,8 +256,9 @@ var ConfigParamsSchema = z3.object({
   delete: z3.boolean(),
   // New non-experimental options
   global: optional(z3.boolean()),
-  simulatedCommands: optional(z3.boolean()),
-  simulatedSubagents: optional(z3.boolean()),
+  simulateCommands: optional(z3.boolean()),
+  simulateSubagents: optional(z3.boolean()),
+  simulateSkills: optional(z3.boolean()),
   modularMcp: optional(z3.boolean()),
   // Deprecated experimental options (for backward compatibility)
   experimentalGlobal: optional(z3.boolean()),
@@ -248,8 +274,9 @@ var Config = class {
   verbose;
   delete;
   global;
-  simulatedCommands;
-  simulatedSubagents;
+  simulateCommands;
+  simulateSubagents;
+  simulateSkills;
   modularMcp;
   constructor({
     baseDirs,
@@ -258,8 +285,9 @@ var Config = class {
     verbose,
     delete: isDelete,
     global,
-    simulatedCommands,
-    simulatedSubagents,
+    simulateCommands,
+    simulateSubagents,
+    simulateSkills,
     modularMcp,
     experimentalGlobal,
     experimentalSimulateCommands,
@@ -271,8 +299,9 @@ var Config = class {
     this.verbose = verbose;
     this.delete = isDelete;
     this.global = global ?? experimentalGlobal ?? false;
-    this.simulatedCommands = simulatedCommands ?? experimentalSimulateCommands ?? false;
-    this.simulatedSubagents = simulatedSubagents ?? experimentalSimulateSubagents ?? false;
+    this.simulateCommands = simulateCommands ?? experimentalSimulateCommands ?? false;
+    this.simulateSubagents = simulateSubagents ?? experimentalSimulateSubagents ?? false;
+    this.simulateSkills = simulateSkills ?? false;
     this.modularMcp = modularMcp ?? false;
   }
   getBaseDirs() {
@@ -299,11 +328,14 @@ var Config = class {
   getGlobal() {
     return this.global;
   }
-  getSimulatedCommands() {
-    return this.simulatedCommands;
+  getSimulateCommands() {
+    return this.simulateCommands;
   }
-  getSimulatedSubagents() {
-    return this.simulatedSubagents;
+  getSimulateSubagents() {
+    return this.simulateSubagents;
+  }
+  getSimulateSkills() {
+    return this.simulateSkills;
   }
   getModularMcp() {
     return this.modularMcp;
@@ -313,13 +345,13 @@ var Config = class {
   getExperimentalGlobal() {
     return this.global;
   }
-  /** @deprecated Use getSimulatedCommands() instead */
+  /** @deprecated Use getSimulateCommands() instead */
   getExperimentalSimulateCommands() {
-    return this.simulatedCommands;
+    return this.simulateCommands;
   }
-  /** @deprecated Use getSimulatedSubagents() instead */
+  /** @deprecated Use getSimulateSubagents() instead */
   getExperimentalSimulateSubagents() {
-    return this.simulatedSubagents;
+    return this.simulateSubagents;
   }
 };
 
@@ -332,8 +364,9 @@ var getDefaults = () => ({
   baseDirs: [process.cwd()],
   configPath: "rulesync.jsonc",
   global: false,
-  simulatedCommands: false,
-  simulatedSubagents: false,
+  simulateCommands: false,
+  simulateSubagents: false,
+  simulateSkills: false,
   modularMcp: false,
   experimentalGlobal: false,
   experimentalSimulateCommands: false,
@@ -348,8 +381,9 @@ var ConfigResolver = class {
     baseDirs,
     configPath = getDefaults().configPath,
     global,
-    simulatedCommands,
-    simulatedSubagents,
+    simulateCommands,
+    simulateSubagents,
+    simulateSkills,
     modularMcp,
     experimentalGlobal,
     experimentalSimulateCommands,
@@ -380,8 +414,9 @@ var ConfigResolver = class {
       warnDeprecatedOptions({ experimentalSimulateSubagents: deprecatedSubagents });
     }
     const resolvedGlobal = global ?? configByFile.global ?? experimentalGlobal ?? configByFile.experimentalGlobal ?? getDefaults().global;
-    const resolvedSimulatedCommands = simulatedCommands ?? configByFile.simulatedCommands ?? experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands ?? getDefaults().simulatedCommands;
-    const resolvedSimulatedSubagents = simulatedSubagents ?? configByFile.simulatedSubagents ?? experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents ?? getDefaults().simulatedSubagents;
+    const resolvedSimulateCommands = simulateCommands ?? configByFile.simulateCommands ?? experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands ?? getDefaults().simulateCommands;
+    const resolvedSimulateSubagents = simulateSubagents ?? configByFile.simulateSubagents ?? experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents ?? getDefaults().simulateSubagents;
+    const resolvedSimulateSkills = simulateSkills ?? configByFile.simulateSkills ?? getDefaults().simulateSkills;
     const configParams = {
       targets: targets ?? configByFile.targets ?? getDefaults().targets,
       features: features ?? configByFile.features ?? getDefaults().features,
@@ -392,8 +427,9 @@ var ConfigResolver = class {
         global: resolvedGlobal
       }),
       global: resolvedGlobal,
-      simulatedCommands: resolvedSimulatedCommands,
-      simulatedSubagents: resolvedSimulatedSubagents,
+      simulateCommands: resolvedSimulateCommands,
+      simulateSubagents: resolvedSimulateSubagents,
+      simulateSkills: resolvedSimulateSkills,
       modularMcp: modularMcp ?? configByFile.modularMcp ?? getDefaults().modularMcp
     };
     return new Config(configParams);
@@ -409,12 +445,12 @@ function warnDeprecatedOptions({
   }
   if (experimentalSimulateCommands !== void 0) {
     logger.warn(
-      "'experimentalSimulateCommands' option is deprecated. Please use 'simulatedCommands' instead."
+      "'experimentalSimulateCommands' option is deprecated. Please use 'simulateCommands' instead."
     );
   }
   if (experimentalSimulateSubagents !== void 0) {
     logger.warn(
-      "'experimentalSimulateSubagents' option is deprecated. Please use 'simulatedSubagents' instead."
+      "'experimentalSimulateSubagents' option is deprecated. Please use 'simulateSubagents' instead."
     );
   }
 }
@@ -1674,7 +1710,7 @@ var CommandsProcessor = class extends FeatureProcessor {
     );
     const rulesyncCommands = (await Promise.allSettled(
       rulesyncCommandPaths.map(
-        (path2) => RulesyncCommand.fromFile({ relativeFilePath: basename11(path2) })
+        (path3) => RulesyncCommand.fromFile({ relativeFilePath: basename11(path3) })
       )
     )).filter((result) => result.status === "fulfilled").map((result) => result.value);
     logger.info(`Successfully loaded ${rulesyncCommands.length} rulesync commands`);
@@ -1684,7 +1720,9 @@ var CommandsProcessor = class extends FeatureProcessor {
    * Implementation of abstract method from FeatureProcessor
    * Load tool-specific command configurations and parse them into ToolCommand instances
    */
-  async loadToolFiles() {
+  async loadToolFiles({
+    forDeletion: _forDeletion = false
+  } = {}) {
     switch (this.toolTarget) {
       case "agentsmd":
         return await this.loadAgentsmdCommands();
@@ -1704,9 +1742,6 @@ var CommandsProcessor = class extends FeatureProcessor {
         throw new Error(`Unsupported tool target: ${this.toolTarget}`);
     }
   }
-  async loadToolFilesToDelete() {
-    return this.loadToolFiles();
-  }
   async loadToolCommandDefault({
     toolTarget,
     relativeDirPath,
@@ -1716,45 +1751,45 @@ var CommandsProcessor = class extends FeatureProcessor {
       join12(this.baseDir, relativeDirPath, `*.${extension}`)
     );
     const toolCommands = (await Promise.allSettled(
-      commandFilePaths.map((path2) => {
+      commandFilePaths.map((path3) => {
         switch (toolTarget) {
           case "agentsmd":
             return AgentsmdCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2)
+              relativeFilePath: basename11(path3)
             });
           case "claudecode":
             return ClaudecodeCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           case "geminicli":
             return GeminiCliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           case "roo":
             return RooCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2)
+              relativeFilePath: basename11(path3)
             });
           case "copilot":
             return CopilotCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2)
+              relativeFilePath: basename11(path3)
             });
           case "cursor":
             return CursorCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           case "codexcli":
             return CodexcliCommand.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename11(path2),
+              relativeFilePath: basename11(path3),
               global: this.global
             });
           default:
@@ -1844,8 +1879,12 @@ var CommandsProcessor = class extends FeatureProcessor {
    * Return the tool targets that this processor supports
    */
   static getToolTargets({
+    global = false,
     includeSimulated = false
   } = {}) {
+    if (global) {
+      return commandsProcessorToolTargetsGlobal;
+    }
     if (!includeSimulated) {
       return commandsProcessorToolTargets.filter(
         (target) => !commandsProcessorToolTargetsSimulated.includes(target)
@@ -1856,9 +1895,6 @@ var CommandsProcessor = class extends FeatureProcessor {
   static getToolTargetsSimulated() {
     return commandsProcessorToolTargetsSimulated;
   }
-  static getToolTargetsGlobal() {
-    return commandsProcessorToolTargetsGlobal;
-  }
 };
 
 // src/features/ignore/ignore-processor.ts
@@ -2282,7 +2318,7 @@ var JunieIgnore = class _JunieIgnore extends ToolIgnore {
   static getSettablePaths() {
     return {
       relativeDirPath: ".",
-      relativeFilePath: ".junieignore"
+      relativeFilePath: ".aiignore"
     };
   }
   toRulesyncIgnore() {
@@ -2546,9 +2582,14 @@ var IgnoreProcessor = class extends FeatureProcessor {
    * Implementation of abstract method from FeatureProcessor
    * Load tool-specific ignore configurations and parse them into ToolIgnore instances
    */
-  async loadToolFiles() {
+  async loadToolFiles({
+    forDeletion = false
+  } = {}) {
     try {
       const toolIgnores = await this.loadToolIgnores();
+      if (forDeletion) {
+        return toolIgnores.filter((toolFile) => !(toolFile instanceof ClaudecodeIgnore));
+      }
       return toolIgnores;
     } catch (error) {
       const errorMessage = `Failed to load tool files: ${formatError(error)}`;
@@ -2588,11 +2629,6 @@ var IgnoreProcessor = class extends FeatureProcessor {
         throw new Error(`Unsupported tool target: ${this.toolTarget}`);
     }
   }
-  async loadToolFilesToDelete() {
-    return (await this.loadToolFiles()).filter(
-      (toolFile) => !(toolFile instanceof ClaudecodeIgnore)
-    );
-  }
   /**
    * Implementation of abstract method from FeatureProcessor
    * Convert RulesyncFile[] to ToolFile[]
@@ -2684,13 +2720,16 @@ var IgnoreProcessor = class extends FeatureProcessor {
    * Implementation of abstract method from FeatureProcessor
    * Return the tool targets that this processor supports
    */
-  static getToolTargets() {
+  static getToolTargets({ global = false } = {}) {
+    if (global) {
+      throw new Error("IgnoreProcessor does not support global mode");
+    }
     return ignoreProcessorToolTargets;
   }
 };
 
 // src/features/mcp/mcp-processor.ts
-import { z as z15 } from "zod/mini";
+import { z as z16 } from "zod/mini";
 
 // src/features/mcp/amazonqcli-mcp.ts
 import { join as join26 } from "path";
@@ -2819,21 +2858,23 @@ var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
       modularMcp
     });
   }
-  getExposedMcpServers() {
-    return Object.fromEntries(
-      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => !this.modularMcp || serverConfig.exposed).map(([serverName, serverConfig]) => [
-        serverName,
-        omit(serverConfig, ["targets", "description", "exposed"])
-      ])
-    );
-  }
-  getModularizedMcpServers() {
+  getMcpServers({ type = "all" } = {}) {
+    const entries = Object.entries(this.json.mcpServers);
+    const filteredEntries = entries.filter(([, serverConfig]) => {
+      switch (type) {
+        case "all":
+          return true;
+        case "exposed":
+          return !this.modularMcp || serverConfig.exposed;
+        case "modularized":
+          return this.modularMcp && !serverConfig.exposed;
+      }
+    });
     return Object.fromEntries(
-      Object.entries(this.json.mcpServers).filter(([, serverConfig]) => this.modularMcp && !serverConfig.exposed).map(([serverName, serverConfig]) => [
-        serverName,
-        // description is required for modular-mcp servers
-        omit(serverConfig, ["targets", "exposed"])
-      ])
+      filteredEntries.map(([serverName, serverConfig]) => {
+        const fieldsToOmit = type === "modularized" ? ["targets", "exposed"] : ["targets", "description", "exposed"];
+        return [serverName, omit(serverConfig, fieldsToOmit)];
+      })
     );
   }
   getJson() {
@@ -3020,7 +3061,7 @@ var ModularMcp = class _ModularMcp extends AiFile {
       global && relativeDirPath ? { global: true, relativeDirPath } : { global: false, relativeDirPath: void 0 }
     );
     const modularMcpJson = {
-      mcpServers: rulesyncMcp.getModularizedMcpServers()
+      mcpServers: rulesyncMcp.getMcpServers({ type: "modularized" })
     };
     return new _ModularMcp({
       baseDir,
@@ -3103,9 +3144,9 @@ var ClaudecodeMcp = class _ClaudecodeMcp extends ToolMcp {
           relativeDirPath: this.getSettablePaths({ global: true }).relativeDirPath
         }) : ModularMcp.getMcpServers({ baseDir, global: false }),
         // Merge exposed servers
-        ...rulesyncMcp.getExposedMcpServers()
+        ...rulesyncMcp.getMcpServers({ type: "exposed" })
       }
-    } : { ...json, mcpServers: rulesyncMcp.getExposedMcpServers() };
+    } : { ...json, mcpServers: rulesyncMcp.getMcpServers({ type: "exposed" }) };
     return new _ClaudecodeMcp({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
@@ -3474,8 +3515,235 @@ var GeminiCliMcp = class _GeminiCliMcp extends ToolMcp {
   }
 };
 
-// src/features/mcp/roo-mcp.ts
+// src/features/mcp/junie-mcp.ts
 import { join as join34 } from "path";
+var JunieMcp = class _JunieMcp extends ToolMcp {
+  json;
+  constructor(params) {
+    super(params);
+    this.json = this.fileContent !== void 0 ? JSON.parse(this.fileContent) : {};
+  }
+  getJson() {
+    return this.json;
+  }
+  static getSettablePaths() {
+    return {
+      relativeDirPath: join34(".junie", "mcp"),
+      relativeFilePath: "mcp.json"
+    };
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true
+  }) {
+    const fileContent = await readFileContent(
+      join34(
+        baseDir,
+        this.getSettablePaths().relativeDirPath,
+        this.getSettablePaths().relativeFilePath
+      )
+    );
+    return new _JunieMcp({
+      baseDir,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
+      relativeFilePath: this.getSettablePaths().relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static fromRulesyncMcp({
+    baseDir = process.cwd(),
+    rulesyncMcp,
+    validate = true
+  }) {
+    return new _JunieMcp({
+      baseDir,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
+      relativeFilePath: this.getSettablePaths().relativeFilePath,
+      fileContent: rulesyncMcp.getFileContent(),
+      validate
+    });
+  }
+  toRulesyncMcp() {
+    return this.toRulesyncMcpDefault();
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+};
+
+// src/features/mcp/opencode-mcp.ts
+import { join as join35 } from "path";
+import { z as z15 } from "zod/mini";
+var OpencodeMcpLocalServerSchema = z15.object({
+  type: z15.literal("local"),
+  command: z15.array(z15.string()),
+  environment: z15.optional(z15.record(z15.string(), z15.string())),
+  enabled: z15._default(z15.boolean(), true),
+  cwd: z15.optional(z15.string())
+});
+var OpencodeMcpRemoteServerSchema = z15.object({
+  type: z15.literal("remote"),
+  url: z15.string(),
+  headers: z15.optional(z15.record(z15.string(), z15.string())),
+  enabled: z15._default(z15.boolean(), true)
+});
+var OpencodeMcpServerSchema = z15.union([
+  OpencodeMcpLocalServerSchema,
+  OpencodeMcpRemoteServerSchema
+]);
+var OpencodeConfigSchema = z15.looseObject({
+  $schema: z15.optional(z15.string()),
+  mcp: z15.optional(z15.record(z15.string(), OpencodeMcpServerSchema))
+});
+function convertFromOpencodeFormat(opencodeMcp) {
+  return Object.fromEntries(
+    Object.entries(opencodeMcp).map(([serverName, serverConfig]) => {
+      if (serverConfig.type === "remote") {
+        return [
+          serverName,
+          {
+            type: "sse",
+            url: serverConfig.url,
+            ...serverConfig.enabled === false && { disabled: true },
+            ...serverConfig.headers && { headers: serverConfig.headers }
+          }
+        ];
+      }
+      const [command, ...args] = serverConfig.command;
+      if (!command) {
+        throw new Error(`Server "${serverName}" has an empty command array`);
+      }
+      return [
+        serverName,
+        {
+          type: "stdio",
+          command,
+          ...args.length > 0 && { args },
+          ...serverConfig.enabled === false && { disabled: true },
+          ...serverConfig.environment && { env: serverConfig.environment },
+          ...serverConfig.cwd && { cwd: serverConfig.cwd }
+        }
+      ];
+    })
+  );
+}
+function convertToOpencodeFormat(mcpServers) {
+  return Object.fromEntries(
+    Object.entries(mcpServers).map(([serverName, serverConfig]) => {
+      const isRemote = serverConfig.type === "sse" || serverConfig.type === "http" || serverConfig.url;
+      if (isRemote) {
+        const remoteServer = {
+          type: "remote",
+          url: serverConfig.url ?? serverConfig.httpUrl ?? "",
+          enabled: serverConfig.disabled !== void 0 ? !serverConfig.disabled : true,
+          ...serverConfig.headers && { headers: serverConfig.headers }
+        };
+        return [serverName, remoteServer];
+      }
+      const commandArray = [];
+      if (serverConfig.command) {
+        if (Array.isArray(serverConfig.command)) {
+          commandArray.push(...serverConfig.command);
+        } else {
+          commandArray.push(serverConfig.command);
+        }
+      }
+      if (serverConfig.args) {
+        commandArray.push(...serverConfig.args);
+      }
+      const localServer = {
+        type: "local",
+        command: commandArray,
+        enabled: serverConfig.disabled !== void 0 ? !serverConfig.disabled : true,
+        ...serverConfig.env && { environment: serverConfig.env },
+        ...serverConfig.cwd && { cwd: serverConfig.cwd }
+      };
+      return [serverName, localServer];
+    })
+  );
+}
+var OpencodeMcp = class _OpencodeMcp extends ToolMcp {
+  json;
+  constructor(params) {
+    super(params);
+    this.json = OpencodeConfigSchema.parse(JSON.parse(this.fileContent || "{}"));
+  }
+  getJson() {
+    return this.json;
+  }
+  static getSettablePaths({ global } = {}) {
+    if (global) {
+      return {
+        relativeDirPath: ".",
+        relativeFilePath: "opencode.json"
+      };
+    }
+    return {
+      relativeDirPath: ".",
+      relativeFilePath: "opencode.json"
+    };
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const fileContent = await readOrInitializeFileContent(
+      join35(baseDir, paths.relativeDirPath, paths.relativeFilePath),
+      JSON.stringify({ mcp: {} }, null, 2)
+    );
+    const json = JSON.parse(fileContent);
+    const newJson = { ...json, mcp: json.mcp ?? {} };
+    return new _OpencodeMcp({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(newJson, null, 2),
+      validate
+    });
+  }
+  static async fromRulesyncMcp({
+    baseDir = process.cwd(),
+    rulesyncMcp,
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const fileContent = await readOrInitializeFileContent(
+      join35(baseDir, paths.relativeDirPath, paths.relativeFilePath),
+      JSON.stringify({ mcp: {} }, null, 2)
+    );
+    const json = JSON.parse(fileContent);
+    const convertedMcp = convertToOpencodeFormat(rulesyncMcp.getMcpServers());
+    const newJson = { ...json, mcp: convertedMcp };
+    return new _OpencodeMcp({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(newJson, null, 2),
+      validate
+    });
+  }
+  toRulesyncMcp() {
+    const convertedMcpServers = convertFromOpencodeFormat(this.json.mcp ?? {});
+    return this.toRulesyncMcpDefault({
+      fileContent: JSON.stringify({ mcpServers: convertedMcpServers }, null, 2)
+    });
+  }
+  validate() {
+    const json = JSON.parse(this.fileContent || "{}");
+    const result = OpencodeConfigSchema.safeParse(json);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    return { success: true, error: null };
+  }
+};
+
+// src/features/mcp/roo-mcp.ts
+import { join as join36 } from "path";
 var RooMcp = class _RooMcp extends ToolMcp {
   json;
   constructor(params) {
@@ -3496,7 +3764,7 @@ var RooMcp = class _RooMcp extends ToolMcp {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join34(
+      join36(
         baseDir,
         this.getSettablePaths().relativeDirPath,
         this.getSettablePaths().relativeFilePath
@@ -3537,16 +3805,23 @@ var mcpProcessorToolTargets = [
   "amazonqcli",
   "claudecode",
   "cline",
+  "junie",
   "copilot",
   "cursor",
   "geminicli",
+  "opencode",
   "roo"
 ];
-var McpProcessorToolTargetSchema = z15.enum(
+var McpProcessorToolTargetSchema = z16.enum(
   // codexcli is not in the list of tool targets but we add it here because it is a valid tool target for global mode generation
   mcpProcessorToolTargets.concat("codexcli")
 );
-var mcpProcessorToolTargetsGlobal = ["claudecode", "codexcli", "geminicli"];
+var mcpProcessorToolTargetsGlobal = [
+  "claudecode",
+  "codexcli",
+  "geminicli",
+  "opencode"
+];
 var mcpProcessorToolTargetsModular = ["claudecode"];
 var McpProcessor = class extends FeatureProcessor {
   toolTarget;
@@ -3581,19 +3856,13 @@ var McpProcessor = class extends FeatureProcessor {
       return [];
     }
   }
-  async loadToolFilesToDelete() {
-    if (this.global) {
-      return (await this.loadToolFiles()).filter(
-        (toolFile) => !(toolFile instanceof ClaudecodeMcp)
-      );
-    }
-    return this.loadToolFiles();
-  }
   /**
    * Implementation of abstract method from FeatureProcessor
    * Load tool-specific MCP configurations and parse them into ToolMcp instances
    */
-  async loadToolFiles() {
+  async loadToolFiles({
+    forDeletion = false
+  } = {}) {
     try {
       const toolMcps = await (async () => {
         switch (this.toolTarget) {
@@ -3622,6 +3891,14 @@ var McpProcessor = class extends FeatureProcessor {
               })
             ];
           }
+          case "junie": {
+            return [
+              await JunieMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true
+              })
+            ];
+          }
           case "codexcli": {
             return [
               await CodexcliMcp.fromFile({
@@ -3656,6 +3933,15 @@ var McpProcessor = class extends FeatureProcessor {
               })
             ];
           }
+          case "opencode": {
+            return [
+              await OpencodeMcp.fromFile({
+                baseDir: this.baseDir,
+                validate: true,
+                global: this.global
+              })
+            ];
+          }
           case "roo": {
             return [
               await RooMcp.fromFile({
@@ -3669,6 +3955,13 @@ var McpProcessor = class extends FeatureProcessor {
         }
       })();
       logger.info(`Successfully loaded ${toolMcps.length} ${this.toolTarget} MCP files`);
+      if (forDeletion) {
+        let filteredMcps = toolMcps.filter((toolFile) => !(toolFile instanceof OpencodeMcp));
+        if (this.global) {
+          filteredMcps = filteredMcps.filter((toolFile) => !(toolFile instanceof ClaudecodeMcp));
+        }
+        return filteredMcps;
+      }
       return toolMcps;
     } catch (error) {
       const errorMessage = `Failed to load MCP files for tool target: ${this.toolTarget}: ${formatError(error)}`;
@@ -3677,119 +3970,1159 @@ var McpProcessor = class extends FeatureProcessor {
       } else {
         logger.error(errorMessage);
       }
-      return [];
+      return [];
+    }
+  }
+  /**
+   * Implementation of abstract method from FeatureProcessor
+   * Convert RulesyncFile[] to ToolFile[]
+   */
+  async convertRulesyncFilesToToolFiles(rulesyncFiles) {
+    const rulesyncMcp = rulesyncFiles.find(
+      (file) => file instanceof RulesyncMcp
+    );
+    if (!rulesyncMcp) {
+      throw new Error(`No ${RULESYNC_MCP_RELATIVE_FILE_PATH} found.`);
+    }
+    const toolMcps = await Promise.all(
+      [rulesyncMcp].map(async (rulesyncMcp2) => {
+        switch (this.toolTarget) {
+          case "amazonqcli":
+            return AmazonqcliMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2
+            });
+          case "claudecode":
+            return await ClaudecodeMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2,
+              global: this.global,
+              modularMcp: this.modularMcp
+            });
+          case "cline":
+            return ClineMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2
+            });
+          case "junie":
+            return JunieMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2
+            });
+          case "copilot":
+            return CopilotMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2
+            });
+          case "cursor":
+            return CursorMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2
+            });
+          case "codexcli":
+            return await CodexcliMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2,
+              global: this.global
+            });
+          case "geminicli":
+            return GeminiCliMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2,
+              global: this.global
+            });
+          case "opencode":
+            return OpencodeMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2,
+              global: this.global
+            });
+          case "roo":
+            return RooMcp.fromRulesyncMcp({
+              baseDir: this.baseDir,
+              rulesyncMcp: rulesyncMcp2
+            });
+          default:
+            throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+        }
+      })
+    );
+    const toolFiles = toolMcps;
+    if (this.modularMcp && mcpProcessorToolTargetsModular.includes(this.toolTarget)) {
+      const relativeDirPath = this.toolTarget === "claudecode" ? ClaudecodeMcp.getSettablePaths({ global: this.global }).relativeDirPath : void 0;
+      toolFiles.push(
+        ModularMcp.fromRulesyncMcp({
+          baseDir: this.baseDir,
+          rulesyncMcp,
+          ...this.global && relativeDirPath ? { global: true, relativeDirPath } : { global: false }
+        })
+      );
+    }
+    return toolFiles;
+  }
+  /**
+   * Implementation of abstract method from FeatureProcessor
+   * Convert ToolFile[] to RulesyncFile[]
+   */
+  async convertToolFilesToRulesyncFiles(toolFiles) {
+    const toolMcps = toolFiles.filter((file) => file instanceof ToolMcp);
+    const rulesyncMcps = toolMcps.map((toolMcp) => {
+      return toolMcp.toRulesyncMcp();
+    });
+    return rulesyncMcps;
+  }
+  /**
+   * Implementation of abstract method from FeatureProcessor
+   * Return the tool targets that this processor supports
+   */
+  static getToolTargets({ global = false } = {}) {
+    if (global) {
+      return mcpProcessorToolTargetsGlobal;
+    }
+    return mcpProcessorToolTargets;
+  }
+};
+
+// src/features/rules/rules-processor.ts
+import { basename as basename19, join as join77 } from "path";
+import { XMLBuilder } from "fast-xml-parser";
+import { z as z29 } from "zod/mini";
+
+// src/features/skills/codexcli-skill.ts
+import { join as join39 } from "path";
+
+// src/features/skills/simulated-skill.ts
+import { join as join38 } from "path";
+import { z as z17 } from "zod/mini";
+
+// src/constants/general.ts
+var SKILL_FILE_NAME = "SKILL.md";
+
+// src/types/ai-dir.ts
+import path2, { basename as basename12, join as join37, relative as relative3, resolve as resolve4 } from "path";
+var AiDir = class {
+  /**
+   * @example "."
+   */
+  baseDir;
+  /**
+   * @example ".rulesync/skills"
+   */
+  relativeDirPath;
+  /**
+   * @example "my-skill"
+   */
+  dirName;
+  /**
+   * Optional main file with frontmatter support
+   */
+  mainFile;
+  /**
+   * Additional files in the directory
+   */
+  otherFiles;
+  /**
+   * @example false
+   */
+  global;
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName,
+    mainFile,
+    otherFiles = [],
+    global = false
+  }) {
+    if (dirName.includes(path2.sep) || dirName.includes("/") || dirName.includes("\\")) {
+      throw new Error(`Directory name cannot contain path separators: dirName="${dirName}"`);
+    }
+    this.baseDir = baseDir;
+    this.relativeDirPath = relativeDirPath;
+    this.dirName = dirName;
+    this.mainFile = mainFile;
+    this.otherFiles = otherFiles;
+    this.global = global;
+  }
+  static async fromDir(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  getBaseDir() {
+    return this.baseDir;
+  }
+  getRelativeDirPath() {
+    return this.relativeDirPath;
+  }
+  getDirName() {
+    return this.dirName;
+  }
+  getDirPath() {
+    const fullPath = path2.join(this.baseDir, this.relativeDirPath, this.dirName);
+    const resolvedFull = resolve4(fullPath);
+    const resolvedBase = resolve4(this.baseDir);
+    const rel = relative3(resolvedBase, resolvedFull);
+    if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+      throw new Error(
+        `Path traversal detected: Final path escapes baseDir. baseDir="${this.baseDir}", relativeDirPath="${this.relativeDirPath}", dirName="${this.dirName}"`
+      );
+    }
+    return fullPath;
+  }
+  getMainFile() {
+    return this.mainFile;
+  }
+  getOtherFiles() {
+    return this.otherFiles;
+  }
+  getRelativePathFromCwd() {
+    return path2.join(this.relativeDirPath, this.dirName);
+  }
+  getGlobal() {
+    return this.global;
+  }
+  setMainFile(name, body, frontmatter) {
+    this.mainFile = { name, body, frontmatter };
+  }
+  /**
+   * Recursively collects all files from a directory, excluding the specified main file.
+   * This is a common utility for loading additional files alongside the main file.
+   *
+   * @param baseDir - The base directory path
+   * @param relativeDirPath - The relative path to the directory containing the skill
+   * @param dirName - The name of the directory
+   * @param excludeFileName - The name of the file to exclude (typically the main file)
+   * @returns Array of files with their relative paths and buffers
+   */
+  static async collectOtherFiles(baseDir, relativeDirPath, dirName, excludeFileName) {
+    const dirPath = join37(baseDir, relativeDirPath, dirName);
+    const glob = join37(dirPath, "**", "*");
+    const filePaths = await findFilesByGlobs(glob, { type: "file" });
+    const filteredPaths = filePaths.filter((filePath) => basename12(filePath) !== excludeFileName);
+    const files = await Promise.all(
+      filteredPaths.map(async (filePath) => {
+        const fileBuffer = await readFileBuffer(filePath);
+        return {
+          relativeFilePathToDirPath: relative3(dirPath, filePath),
+          fileBuffer
+        };
+      })
+    );
+    return files;
+  }
+};
+
+// src/features/skills/tool-skill.ts
+var ToolSkill = class extends AiDir {
+  /**
+   * Get the settable paths for this tool's skill directories.
+   *
+   * @param options - Optional configuration including global mode
+   * @returns Object containing the relative directory path
+   */
+  static getSettablePaths(_options) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Load a skill from a tool-specific directory.
+   *
+   * This method should:
+   * 1. Read the SKILL.md file content
+   * 2. Parse tool-specific frontmatter format
+   * 3. Validate the parsed data
+   * 4. Collect other skill files in the directory
+   * 5. Return a concrete ToolSkill instance
+   *
+   * @param params - Parameters including the skill directory name
+   * @returns Promise resolving to a concrete ToolSkill instance
+   */
+  static async fromDir(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Convert a RulesyncSkill to the tool-specific skill format.
+   *
+   * This method should:
+   * 1. Extract relevant data from the RulesyncSkill
+   * 2. Transform frontmatter to tool-specific format
+   * 3. Transform body content if needed
+   * 4. Preserve other skill files
+   * 5. Return a concrete ToolSkill instance
+   *
+   * @param params - Parameters including the RulesyncSkill to convert
+   * @returns A concrete ToolSkill instance
+   */
+  static fromRulesyncSkill(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Check if this tool is targeted by a RulesyncSkill.
+   * Since skills don't have targets field like commands/subagents,
+   * the default behavior may vary by tool.
+   *
+   * @param rulesyncSkill - The RulesyncSkill to check
+   * @returns True if this tool should use the skill
+   */
+  static isTargetedByRulesyncSkill(_rulesyncSkill) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+};
+
+// src/features/skills/simulated-skill.ts
+var SimulatedSkillFrontmatterSchema = z17.object({
+  name: z17.string(),
+  description: z17.string()
+});
+var SimulatedSkill = class extends ToolSkill {
+  frontmatter;
+  body;
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName,
+    frontmatter,
+    body,
+    otherFiles = [],
+    validate = true
+  }) {
+    super({
+      baseDir,
+      relativeDirPath,
+      dirName,
+      mainFile: {
+        name: SKILL_FILE_NAME,
+        body,
+        frontmatter: { ...frontmatter }
+      },
+      otherFiles,
+      global: false
+      // Simulated skills are project mode only
+    });
+    if (validate) {
+      const result = SimulatedSkillFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${join38(relativeDirPath, dirName)}: ${formatError(result.error)}`
+        );
+      }
+    }
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
+  getBody() {
+    return this.body;
+  }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  toRulesyncSkill() {
+    throw new Error("Not implemented because it is a SIMULATED skill.");
+  }
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = SimulatedSkillFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${this.getDirPath()}: ${formatError(result.error)}`
+        )
+      };
+    }
+  }
+  static fromRulesyncSkillDefault({
+    rulesyncSkill,
+    validate = true
+  }) {
+    const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+    const simulatedFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description
+    };
+    const otherFiles = rulesyncSkill.getOtherFiles();
+    if (otherFiles.length > 0) {
+      logger.warn(
+        `Skill "${rulesyncFrontmatter.name}" has ${otherFiles.length} additional file(s) that will be ignored for simulated skill generation.`
+      );
+    }
+    return {
+      baseDir: rulesyncSkill.getBaseDir(),
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
+      dirName: rulesyncSkill.getDirName(),
+      frontmatter: simulatedFrontmatter,
+      body: rulesyncSkill.getBody(),
+      otherFiles: [],
+      // Simulated skills ignore otherFiles
+      validate
+    };
+  }
+  static async fromDirDefault({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName
+  }) {
+    const settablePaths = this.getSettablePaths();
+    const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
+    const skillDirPath = join38(baseDir, actualRelativeDirPath, dirName);
+    const skillFilePath = join38(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)}`);
+    }
+    return {
+      baseDir,
+      relativeDirPath: actualRelativeDirPath,
+      dirName,
+      frontmatter: result.data,
+      body: content.trim(),
+      otherFiles: [],
+      // Simulated skills ignore 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/codexcli-skill.ts
+var CodexCliSkill = class _CodexCliSkill extends SimulatedSkill {
+  static getSettablePaths(options) {
+    if (options?.global) {
+      throw new Error("CodexCliSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: join39(".codex", "skills")
+    };
+  }
+  static async fromDir(params) {
+    const baseParams = await this.fromDirDefault(params);
+    return new _CodexCliSkill(baseParams);
+  }
+  static fromRulesyncSkill(params) {
+    const baseParams = {
+      ...this.fromRulesyncSkillDefault(params),
+      relativeDirPath: this.getSettablePaths().relativeDirPath
+    };
+    return new _CodexCliSkill(baseParams);
+  }
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    return this.isTargetedByRulesyncSkillDefault({
+      rulesyncSkill,
+      toolTarget: "codexcli"
+    });
+  }
+};
+
+// src/features/skills/copilot-skill.ts
+import { join as join40 } from "path";
+var CopilotSkill = class _CopilotSkill extends SimulatedSkill {
+  static getSettablePaths(options) {
+    if (options?.global) {
+      throw new Error("CopilotSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: join40(".github", "skills")
+    };
+  }
+  static async fromDir(params) {
+    const baseParams = await this.fromDirDefault(params);
+    return new _CopilotSkill(baseParams);
+  }
+  static fromRulesyncSkill(params) {
+    const baseParams = {
+      ...this.fromRulesyncSkillDefault(params),
+      relativeDirPath: this.getSettablePaths().relativeDirPath
+    };
+    return new _CopilotSkill(baseParams);
+  }
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    return this.isTargetedByRulesyncSkillDefault({
+      rulesyncSkill,
+      toolTarget: "copilot"
+    });
+  }
+};
+
+// src/features/skills/cursor-skill.ts
+import { join as join41 } from "path";
+var CursorSkill = class _CursorSkill extends SimulatedSkill {
+  static getSettablePaths(options) {
+    if (options?.global) {
+      throw new Error("CursorSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: join41(".cursor", "skills")
+    };
+  }
+  static async fromDir(params) {
+    const baseParams = await this.fromDirDefault(params);
+    return new _CursorSkill(baseParams);
+  }
+  static fromRulesyncSkill(params) {
+    const baseParams = {
+      ...this.fromRulesyncSkillDefault(params),
+      relativeDirPath: this.getSettablePaths().relativeDirPath
+    };
+    return new _CursorSkill(baseParams);
+  }
+  static isTargetedByRulesyncSkill(rulesyncSkill) {
+    return this.isTargetedByRulesyncSkillDefault({
+      rulesyncSkill,
+      toolTarget: "cursor"
+    });
+  }
+};
+
+// src/features/skills/skills-processor.ts
+import { basename as basename13, join as join47 } from "path";
+import { z as z20 } from "zod/mini";
+
+// src/types/dir-feature-processor.ts
+import { join as join42 } from "path";
+var DirFeatureProcessor = class {
+  baseDir;
+  constructor({ baseDir = process.cwd() }) {
+    this.baseDir = baseDir;
+  }
+  /**
+   * Return tool targets that this feature supports.
+   */
+  static getToolTargets(_params = {}) {
+    throw new Error("Not implemented");
+  }
+  /**
+   * Once converted to rulesync/tool dirs, write them to the filesystem.
+   * Returns the number of directories written.
+   */
+  async writeAiDirs(aiDirs) {
+    for (const aiDir of aiDirs) {
+      const dirPath = aiDir.getDirPath();
+      await ensureDir(dirPath);
+      const mainFile = aiDir.getMainFile();
+      if (mainFile) {
+        const mainFilePath = join42(dirPath, mainFile.name);
+        const contentWithNewline = addTrailingNewline(mainFile.body);
+        await writeFileContent(mainFilePath, contentWithNewline);
+      }
+      const otherFiles = aiDir.getOtherFiles();
+      for (const file of otherFiles) {
+        const filePath = join42(dirPath, file.relativeFilePathToDirPath);
+        const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
+        await writeFileContent(filePath, contentWithNewline);
+      }
+    }
+    return aiDirs.length;
+  }
+  async removeAiDirs(aiDirs) {
+    for (const aiDir of aiDirs) {
+      await removeDirectory(aiDir.getDirPath());
+    }
+  }
+};
+
+// src/features/skills/agentsmd-skill.ts
+import { join as join43 } from "path";
+var AgentsmdSkill = class _AgentsmdSkill extends SimulatedSkill {
+  static getSettablePaths(options) {
+    if (options?.global) {
+      throw new Error("AgentsmdSkill does not support global mode.");
+    }
+    return {
+      relativeDirPath: join43(".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
+import { join as join45 } from "path";
+import { z as z19 } from "zod/mini";
+
+// src/features/skills/rulesync-skill.ts
+import { join as join44 } from "path";
+import { z as z18 } from "zod/mini";
+var RulesyncSkillFrontmatterSchemaInternal = z18.object({
+  name: z18.string(),
+  description: z18.string(),
+  targets: z18._default(RulesyncTargetsSchema, ["*"]),
+  claudecode: z18.optional(
+    z18.object({
+      "allowed-tools": z18.optional(z18.array(z18.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 = join44(baseDir, relativeDirPath, dirName);
+    const skillFilePath = join44(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/claudecode-skill.ts
+var ClaudecodeSkillFrontmatterSchema = z19.object({
+  name: z19.string(),
+  description: z19.string(),
+  "allowed-tools": z19.optional(z19.array(z19.string()))
+});
+var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
+  constructor({
+    baseDir = process.cwd(),
+    relativeDirPath = join45(".claude", "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: _global = false
+  } = {}) {
+    return {
+      relativeDirPath: join45(".claude", "skills")
+    };
+  }
+  getFrontmatter() {
+    if (!this.mainFile?.frontmatter) {
+      throw new Error("Frontmatter is not defined");
+    }
+    const result = ClaudecodeSkillFrontmatterSchema.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 = ClaudecodeSkillFrontmatterSchema.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: ["*"],
+      ...frontmatter["allowed-tools"] && {
+        claudecode: {
+          "allowed-tools": frontmatter["allowed-tools"]
+        }
+      }
+    };
+    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,
+    validate = true,
+    global = false
+  }) {
+    const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+    const claudecodeFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description,
+      "allowed-tools": rulesyncFrontmatter.claudecode?.["allowed-tools"]
+    };
+    const settablePaths = _ClaudecodeSkill.getSettablePaths({ global });
+    return new _ClaudecodeSkill({
+      baseDir: rulesyncSkill.getBaseDir(),
+      relativeDirPath: settablePaths.relativeDirPath,
+      dirName: rulesyncSkill.getDirName(),
+      frontmatter: claudecodeFrontmatter,
+      body: rulesyncSkill.getBody(),
+      otherFiles: rulesyncSkill.getOtherFiles(),
+      validate,
+      global
+    });
+  }
+  static isTargetedByRulesyncSkill(_rulesyncSkill) {
+    return true;
+  }
+  static async fromDir({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    dirName,
+    global = false
+  }) {
+    const settablePaths = this.getSettablePaths({ global });
+    const actualRelativeDirPath = relativeDirPath ?? settablePaths.relativeDirPath;
+    const skillDirPath = join45(baseDir, actualRelativeDirPath, dirName);
+    const skillFilePath = join45(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 = ClaudecodeSkillFrontmatterSchema.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 new _ClaudecodeSkill({
+      baseDir,
+      relativeDirPath: actualRelativeDirPath,
+      dirName,
+      frontmatter: result.data,
+      body: content.trim(),
+      otherFiles,
+      validate: true,
+      global
+    });
+  }
+};
+
+// src/features/skills/geminicli-skill.ts
+import { join as join46 } 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: join46(".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 skillsProcessorToolTargets = [
+  "claudecode",
+  "copilot",
+  "cursor",
+  "codexcli",
+  "geminicli",
+  "agentsmd"
+];
+var skillsProcessorToolTargetsSimulated = [
+  "copilot",
+  "cursor",
+  "codexcli",
+  "geminicli",
+  "agentsmd"
+];
+var skillsProcessorToolTargetsGlobal = ["claudecode"];
+var SkillsProcessorToolTargetSchema = z20.enum(skillsProcessorToolTargets);
+var SkillsProcessor = class extends DirFeatureProcessor {
+  toolTarget;
+  global;
+  constructor({
+    baseDir = process.cwd(),
+    toolTarget,
+    global = false
+  }) {
+    super({ baseDir });
+    const result = SkillsProcessorToolTargetSchema.safeParse(toolTarget);
+    if (!result.success) {
+      throw new Error(
+        `Invalid tool target for SkillsProcessor: ${toolTarget}. ${formatError(result.error)}`
+      );
+    }
+    this.toolTarget = result.data;
+    this.global = global;
+  }
+  async convertRulesyncDirsToToolDirs(rulesyncDirs) {
+    const rulesyncSkills = rulesyncDirs.filter(
+      (dir) => dir instanceof RulesyncSkill
+    );
+    const toolSkills = [];
+    for (const rulesyncSkill of rulesyncSkills) {
+      switch (this.toolTarget) {
+        case "claudecode":
+          if (!ClaudecodeSkill.isTargetedByRulesyncSkill(rulesyncSkill)) {
+            continue;
+          }
+          toolSkills.push(
+            ClaudecodeSkill.fromRulesyncSkill({
+              rulesyncSkill,
+              global: this.global
+            })
+          );
+          break;
+        case "copilot":
+          if (!CopilotSkill.isTargetedByRulesyncSkill(rulesyncSkill)) {
+            continue;
+          }
+          toolSkills.push(
+            CopilotSkill.fromRulesyncSkill({
+              rulesyncSkill
+            })
+          );
+          break;
+        case "cursor":
+          if (!CursorSkill.isTargetedByRulesyncSkill(rulesyncSkill)) {
+            continue;
+          }
+          toolSkills.push(
+            CursorSkill.fromRulesyncSkill({
+              rulesyncSkill
+            })
+          );
+          break;
+        case "codexcli":
+          if (!CodexCliSkill.isTargetedByRulesyncSkill(rulesyncSkill)) {
+            continue;
+          }
+          toolSkills.push(
+            CodexCliSkill.fromRulesyncSkill({
+              rulesyncSkill
+            })
+          );
+          break;
+        case "geminicli":
+          if (!GeminiCliSkill.isTargetedByRulesyncSkill(rulesyncSkill)) {
+            continue;
+          }
+          toolSkills.push(
+            GeminiCliSkill.fromRulesyncSkill({
+              rulesyncSkill
+            })
+          );
+          break;
+        case "agentsmd":
+          if (!AgentsmdSkill.isTargetedByRulesyncSkill(rulesyncSkill)) {
+            continue;
+          }
+          toolSkills.push(
+            AgentsmdSkill.fromRulesyncSkill({
+              rulesyncSkill
+            })
+          );
+          break;
+        default:
+          throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+      }
+    }
+    return toolSkills;
+  }
+  async convertToolDirsToRulesyncDirs(toolDirs) {
+    const toolSkills = toolDirs.filter((dir) => dir instanceof ToolSkill);
+    const rulesyncSkills = [];
+    for (const toolSkill of toolSkills) {
+      if (toolSkill instanceof SimulatedSkill) {
+        logger.debug(`Skipping simulated skill conversion: ${toolSkill.getDirPath()}`);
+        continue;
+      }
+      rulesyncSkills.push(toolSkill.toRulesyncSkill());
+    }
+    return rulesyncSkills;
+  }
+  /**
+   * Implementation of abstract method from DirFeatureProcessor
+   * Load and parse rulesync skill directories from .rulesync/skills/ directory
+   */
+  async loadRulesyncDirs() {
+    const paths = RulesyncSkill.getSettablePaths();
+    const rulesyncSkillsDirPath = join47(this.baseDir, paths.relativeDirPath);
+    const dirPaths = await findFilesByGlobs(join47(rulesyncSkillsDirPath, "*"), { type: "dir" });
+    const dirNames = dirPaths.map((path3) => basename13(path3));
+    const results = await Promise.allSettled(
+      dirNames.map(
+        (dirName) => RulesyncSkill.fromDir({ baseDir: this.baseDir, dirName, global: this.global })
+      )
+    );
+    const rulesyncSkills = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        rulesyncSkills.push(result.value);
+      }
     }
+    logger.info(`Successfully loaded ${rulesyncSkills.length} rulesync skills`);
+    return rulesyncSkills;
   }
   /**
-   * Implementation of abstract method from FeatureProcessor
-   * Convert RulesyncFile[] to ToolFile[]
+   * Implementation of abstract method from DirFeatureProcessor
+   * Load tool-specific skill configurations and parse them into ToolSkill instances
    */
-  async convertRulesyncFilesToToolFiles(rulesyncFiles) {
-    const rulesyncMcp = rulesyncFiles.find(
-      (file) => file instanceof RulesyncMcp
-    );
-    if (!rulesyncMcp) {
-      throw new Error(`No ${RULESYNC_MCP_RELATIVE_FILE_PATH} found.`);
+  async loadToolDirs() {
+    switch (this.toolTarget) {
+      case "claudecode":
+        return await this.loadClaudecodeSkills();
+      case "copilot":
+        return await this.loadSimulatedSkills(CopilotSkill);
+      case "cursor":
+        return await this.loadSimulatedSkills(CursorSkill);
+      case "codexcli":
+        return await this.loadSimulatedSkills(CodexCliSkill);
+      case "geminicli":
+        return await this.loadSimulatedSkills(GeminiCliSkill);
+      case "agentsmd":
+        return await this.loadSimulatedSkills(AgentsmdSkill);
+      default:
+        throw new Error(`Unsupported tool target: ${this.toolTarget}`);
     }
-    const toolMcps = await Promise.all(
-      [rulesyncMcp].map(async (rulesyncMcp2) => {
-        switch (this.toolTarget) {
-          case "amazonqcli":
-            return AmazonqcliMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2
-            });
-          case "claudecode":
-            return await ClaudecodeMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2,
-              global: this.global,
-              modularMcp: this.modularMcp
-            });
-          case "cline":
-            return ClineMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2
-            });
-          case "copilot":
-            return CopilotMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2
-            });
-          case "cursor":
-            return CursorMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2
-            });
-          case "codexcli":
-            return await CodexcliMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2,
-              global: this.global
-            });
-          case "geminicli":
-            return GeminiCliMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2,
-              global: this.global
-            });
-          case "roo":
-            return RooMcp.fromRulesyncMcp({
-              baseDir: this.baseDir,
-              rulesyncMcp: rulesyncMcp2
-            });
-          default:
-            throw new Error(`Unsupported tool target: ${this.toolTarget}`);
-        }
-      })
-    );
-    const toolFiles = toolMcps;
-    if (this.modularMcp && mcpProcessorToolTargetsModular.includes(this.toolTarget)) {
-      const relativeDirPath = this.toolTarget === "claudecode" ? ClaudecodeMcp.getSettablePaths({ global: this.global }).relativeDirPath : void 0;
-      toolFiles.push(
-        ModularMcp.fromRulesyncMcp({
+  }
+  async loadToolDirsToDelete() {
+    return this.loadToolDirs();
+  }
+  /**
+   * Load Claude Code skill configurations from .claude/skills/ directory
+   */
+  async loadClaudecodeSkills() {
+    const paths = ClaudecodeSkill.getSettablePaths({ global: this.global });
+    const skillsDirPath = join47(this.baseDir, paths.relativeDirPath);
+    const dirPaths = await findFilesByGlobs(join47(skillsDirPath, "*"), { type: "dir" });
+    const dirNames = dirPaths.map((path3) => basename13(path3));
+    const toolSkills = (await Promise.allSettled(
+      dirNames.map(
+        (dirName) => ClaudecodeSkill.fromDir({
           baseDir: this.baseDir,
-          rulesyncMcp,
-          ...this.global && relativeDirPath ? { global: true, relativeDirPath } : { global: false }
+          dirName,
+          global: this.global
         })
-      );
-    }
-    return toolFiles;
+      )
+    )).filter((result) => result.status === "fulfilled").map((result) => result.value);
+    logger.info(`Successfully loaded ${toolSkills.length} ${paths.relativeDirPath} skills`);
+    return toolSkills;
   }
   /**
-   * Implementation of abstract method from FeatureProcessor
-   * Convert ToolFile[] to RulesyncFile[]
+   * Load simulated skill configurations from tool-specific directories
    */
-  async convertToolFilesToRulesyncFiles(toolFiles) {
-    const toolMcps = toolFiles.filter((file) => file instanceof ToolMcp);
-    const rulesyncMcps = toolMcps.map((toolMcp) => {
-      return toolMcp.toRulesyncMcp();
-    });
-    return rulesyncMcps;
+  async loadSimulatedSkills(SkillClass) {
+    const paths = SkillClass.getSettablePaths();
+    const skillsDirPath = join47(this.baseDir, paths.relativeDirPath);
+    const dirPaths = await findFilesByGlobs(join47(skillsDirPath, "*"), { type: "dir" });
+    const dirNames = dirPaths.map((path3) => basename13(path3));
+    const toolSkills = (await Promise.allSettled(
+      dirNames.map(
+        (dirName) => SkillClass.fromDir({
+          baseDir: this.baseDir,
+          dirName
+        })
+      )
+    )).filter((result) => result.status === "fulfilled").map((result) => result.value);
+    logger.info(`Successfully loaded ${toolSkills.length} ${paths.relativeDirPath} skills`);
+    return toolSkills;
   }
   /**
-   * Implementation of abstract method from FeatureProcessor
+   * Implementation of abstract method from DirFeatureProcessor
    * Return the tool targets that this processor supports
    */
-  static getToolTargets() {
-    return mcpProcessorToolTargets;
+  static getToolTargets({
+    global = false,
+    includeSimulated = false
+  } = {}) {
+    if (global) {
+      return skillsProcessorToolTargetsGlobal;
+    }
+    if (!includeSimulated) {
+      return skillsProcessorToolTargets.filter(
+        (target) => !skillsProcessorToolTargetsSimulated.includes(target)
+      );
+    }
+    return skillsProcessorToolTargets;
+  }
+  /**
+   * Return the simulated tool targets
+   */
+  static getToolTargetsSimulated() {
+    return skillsProcessorToolTargetsSimulated;
   }
+  /**
+   * Return the tool targets that this processor supports in global mode
+   */
   static getToolTargetsGlobal() {
-    return mcpProcessorToolTargetsGlobal;
+    return skillsProcessorToolTargetsGlobal;
   }
 };
 
-// src/features/rules/rules-processor.ts
-import { basename as basename17, join as join64 } from "path";
-import { XMLBuilder } from "fast-xml-parser";
-import { z as z24 } from "zod/mini";
-
 // src/features/subagents/agentsmd-subagent.ts
-import { join as join36 } from "path";
+import { join as join49 } from "path";
 
 // src/features/subagents/simulated-subagent.ts
-import { basename as basename12, join as join35 } from "path";
-import { z as z16 } from "zod/mini";
+import { basename as basename14, join as join48 } from "path";
+import { z as z21 } from "zod/mini";
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -3824,9 +5157,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z16.object({
-  name: z16.string(),
-  description: z16.string()
+var SimulatedSubagentFrontmatterSchema = z21.object({
+  name: z21.string(),
+  description: z21.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -3836,7 +5169,7 @@ var SimulatedSubagent = class extends ToolSubagent {
       const result = SimulatedSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join35(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join48(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -3887,7 +5220,7 @@ var SimulatedSubagent = class extends ToolSubagent {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join35(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join48(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -3897,7 +5230,7 @@ var SimulatedSubagent = class extends ToolSubagent {
     relativeFilePath,
     validate = true
   }) {
-    const filePath = join35(baseDir, this.getSettablePaths().relativeDirPath, relativeFilePath);
+    const filePath = join48(baseDir, this.getSettablePaths().relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = SimulatedSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -3907,7 +5240,7 @@ var SimulatedSubagent = class extends ToolSubagent {
     return {
       baseDir,
       relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: basename12(relativeFilePath),
+      relativeFilePath: basename14(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -3919,7 +5252,7 @@ var SimulatedSubagent = class extends ToolSubagent {
 var AgentsmdSubagent = class _AgentsmdSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join36(".agents", "subagents")
+      relativeDirPath: join49(".agents", "subagents")
     };
   }
   static async fromFile(params) {
@@ -3939,11 +5272,11 @@ var AgentsmdSubagent = class _AgentsmdSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/codexcli-subagent.ts
-import { join as join37 } from "path";
+import { join as join50 } from "path";
 var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join37(".codex", "subagents")
+      relativeDirPath: join50(".codex", "subagents")
     };
   }
   static async fromFile(params) {
@@ -3963,11 +5296,11 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/copilot-subagent.ts
-import { join as join38 } from "path";
+import { join as join51 } from "path";
 var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join38(".github", "subagents")
+      relativeDirPath: join51(".github", "subagents")
     };
   }
   static async fromFile(params) {
@@ -3987,11 +5320,11 @@ var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/cursor-subagent.ts
-import { join as join39 } from "path";
+import { join as join52 } from "path";
 var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join39(".cursor", "subagents")
+      relativeDirPath: join52(".cursor", "subagents")
     };
   }
   static async fromFile(params) {
@@ -4011,11 +5344,11 @@ var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/geminicli-subagent.ts
-import { join as join40 } from "path";
+import { join as join53 } from "path";
 var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join40(".gemini", "subagents")
+      relativeDirPath: join53(".gemini", "subagents")
     };
   }
   static async fromFile(params) {
@@ -4035,11 +5368,11 @@ var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/roo-subagent.ts
-import { join as join41 } from "path";
+import { join as join54 } from "path";
 var RooSubagent = class _RooSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join41(".roo", "subagents")
+      relativeDirPath: join54(".roo", "subagents")
     };
   }
   static async fromFile(params) {
@@ -4059,23 +5392,23 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/subagents-processor.ts
-import { basename as basename14, join as join44 } from "path";
-import { z as z19 } from "zod/mini";
+import { basename as basename16, join as join57 } from "path";
+import { z as z24 } from "zod/mini";
 
 // src/features/subagents/claudecode-subagent.ts
-import { join as join43 } from "path";
-import { z as z18 } from "zod/mini";
+import { join as join56 } from "path";
+import { z as z23 } from "zod/mini";
 
 // src/features/subagents/rulesync-subagent.ts
-import { basename as basename13, join as join42 } from "path";
-import { z as z17 } from "zod/mini";
-var RulesyncSubagentModelSchema = z17.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = z17.object({
+import { basename as basename15, join as join55 } from "path";
+import { z as z22 } from "zod/mini";
+var RulesyncSubagentModelSchema = z22.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = z22.object({
   targets: RulesyncTargetsSchema,
-  name: z17.string(),
-  description: z17.string(),
-  claudecode: z17.optional(
-    z17.object({
+  name: z22.string(),
+  description: z22.string(),
+  claudecode: z22.optional(
+    z22.object({
       model: RulesyncSubagentModelSchema
     })
   )
@@ -4088,7 +5421,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join42(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join55(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -4121,7 +5454,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join42(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join55(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -4130,14 +5463,14 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
     relativeFilePath
   }) {
     const fileContent = await readFileContent(
-      join42(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
+      join55(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
     );
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
     }
-    const filename = basename13(relativeFilePath);
+    const filename = basename15(relativeFilePath);
     return new _RulesyncSubagent({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().relativeDirPath,
@@ -4149,10 +5482,10 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z18.object({
-  name: z18.string(),
-  description: z18.string(),
-  model: z18.optional(z18.enum(["opus", "sonnet", "haiku", "inherit"]))
+var ClaudecodeSubagentFrontmatterSchema = z23.object({
+  name: z23.string(),
+  description: z23.string(),
+  model: z23.optional(z23.enum(["opus", "sonnet", "haiku", "inherit"]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -4162,7 +5495,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join43(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join56(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -4174,7 +5507,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: join43(".claude", "agents")
+      relativeDirPath: join56(".claude", "agents")
     };
   }
   getFrontmatter() {
@@ -4240,7 +5573,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join43(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join56(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -4258,7 +5591,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = join43(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = join56(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -4296,7 +5629,7 @@ var subagentsProcessorToolTargetsSimulated = [
   "roo"
 ];
 var subagentsProcessorToolTargetsGlobal = ["claudecode"];
-var SubagentsProcessorToolTargetSchema = z19.enum(subagentsProcessorToolTargets);
+var SubagentsProcessorToolTargetSchema = z24.enum(subagentsProcessorToolTargets);
 var SubagentsProcessor = class extends FeatureProcessor {
   toolTarget;
   global;
@@ -4412,7 +5745,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
    * Load and parse rulesync subagent files from .rulesync/subagents/ directory
    */
   async loadRulesyncFiles() {
-    const subagentsDir = join44(this.baseDir, RulesyncSubagent.getSettablePaths().relativeDirPath);
+    const subagentsDir = join57(this.baseDir, RulesyncSubagent.getSettablePaths().relativeDirPath);
     const dirExists = await directoryExists(subagentsDir);
     if (!dirExists) {
       logger.debug(`Rulesync subagents directory not found: ${subagentsDir}`);
@@ -4427,7 +5760,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
     logger.info(`Found ${mdFiles.length} subagent files in ${subagentsDir}`);
     const rulesyncSubagents = [];
     for (const mdFile of mdFiles) {
-      const filepath = join44(subagentsDir, mdFile);
+      const filepath = join57(subagentsDir, mdFile);
       try {
         const rulesyncSubagent = await RulesyncSubagent.fromFile({
           relativeFilePath: mdFile,
@@ -4451,7 +5784,9 @@ var SubagentsProcessor = class extends FeatureProcessor {
    * Implementation of abstract method from Processor
    * Load tool-specific subagent configurations and parse them into ToolSubagent instances
    */
-  async loadToolFiles() {
+  async loadToolFiles({
+    forDeletion: _forDeletion = false
+  } = {}) {
     switch (this.toolTarget) {
       case "agentsmd":
         return await this.loadAgentsmdSubagents();
@@ -4471,9 +5806,6 @@ var SubagentsProcessor = class extends FeatureProcessor {
         throw new Error(`Unsupported tool target: ${this.toolTarget}`);
     }
   }
-  async loadToolFilesToDelete() {
-    return this.loadToolFiles();
-  }
   /**
    * Load Agents.md subagent configurations from .agents/subagents/ directory
    */
@@ -4546,8 +5878,8 @@ var SubagentsProcessor = class extends FeatureProcessor {
     relativeDirPath,
     fromFile
   }) {
-    const paths = await findFilesByGlobs(join44(this.baseDir, relativeDirPath, "*.md"));
-    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile(basename14(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
+    const paths = await findFilesByGlobs(join57(this.baseDir, relativeDirPath, "*.md"));
+    const subagents = (await Promise.allSettled(paths.map((path3) => fromFile(basename16(path3))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
     logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
     return subagents;
   }
@@ -4556,8 +5888,12 @@ var SubagentsProcessor = class extends FeatureProcessor {
    * Return the tool targets that this processor supports
    */
   static getToolTargets({
+    global = false,
     includeSimulated = false
   } = {}) {
+    if (global) {
+      return subagentsProcessorToolTargetsGlobal;
+    }
     if (!includeSimulated) {
       return subagentsProcessorToolTargets.filter(
         (target) => !subagentsProcessorToolTargetsSimulated.includes(target)
@@ -4568,36 +5904,33 @@ var SubagentsProcessor = class extends FeatureProcessor {
   static getToolTargetsSimulated() {
     return subagentsProcessorToolTargetsSimulated;
   }
-  static getToolTargetsGlobal() {
-    return subagentsProcessorToolTargetsGlobal;
-  }
 };
 
 // src/features/rules/agentsmd-rule.ts
-import { join as join47 } from "path";
+import { join as join60 } from "path";
 
 // src/features/rules/tool-rule.ts
-import { join as join46 } from "path";
+import { join as join59 } from "path";
 
 // src/features/rules/rulesync-rule.ts
-import { basename as basename15, join as join45 } from "path";
-import { z as z20 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z20.object({
-  root: z20.optional(z20.optional(z20.boolean())),
-  targets: z20.optional(RulesyncTargetsSchema),
-  description: z20.optional(z20.string()),
-  globs: z20.optional(z20.array(z20.string())),
-  agentsmd: z20.optional(
-    z20.object({
+import { basename as basename17, join as join58 } from "path";
+import { z as z25 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z25.object({
+  root: z25.optional(z25.optional(z25.boolean())),
+  targets: z25.optional(RulesyncTargetsSchema),
+  description: z25.optional(z25.string()),
+  globs: z25.optional(z25.array(z25.string())),
+  agentsmd: z25.optional(
+    z25.object({
       // @example "path/to/subproject"
-      subprojectPath: z20.optional(z20.string())
+      subprojectPath: z25.optional(z25.string())
     })
   ),
-  cursor: z20.optional(
-    z20.object({
-      alwaysApply: z20.optional(z20.boolean()),
-      description: z20.optional(z20.string()),
-      globs: z20.optional(z20.array(z20.string()))
+  cursor: z25.optional(
+    z25.object({
+      alwaysApply: z25.optional(z25.boolean()),
+      description: z25.optional(z25.string()),
+      globs: z25.optional(z25.array(z25.string()))
     })
   )
 });
@@ -4609,7 +5942,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join45(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join58(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -4644,7 +5977,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join45(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join58(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -4653,12 +5986,12 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
     relativeFilePath,
     validate = true
   }) {
-    const legacyPath = join45(
+    const legacyPath = join58(
       process.cwd(),
       this.getSettablePaths().legacy.relativeDirPath,
       relativeFilePath
     );
-    const recommendedPath = join45(
+    const recommendedPath = join58(
       this.getSettablePaths().recommended.relativeDirPath,
       relativeFilePath
     );
@@ -4677,7 +6010,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       agentsmd: result.data.agentsmd,
       cursor: result.data.cursor
     };
-    const filename = basename15(legacyPath);
+    const filename = basename17(legacyPath);
     return new _RulesyncRule({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
@@ -4691,7 +6024,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
     relativeFilePath,
     validate = true
   }) {
-    const filePath = join45(
+    const filePath = join58(
       process.cwd(),
       this.getSettablePaths().recommended.relativeDirPath,
       relativeFilePath
@@ -4710,7 +6043,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       agentsmd: result.data.agentsmd,
       cursor: result.data.cursor
     };
-    const filename = basename15(filePath);
+    const filename = basename17(filePath);
     return new _RulesyncRule({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
@@ -4785,7 +6118,7 @@ var ToolRule = class extends ToolFile {
     rulesyncRule,
     validate = true,
     rootPath = { relativeDirPath: ".", relativeFilePath: "AGENTS.md" },
-    nonRootPath = { relativeDirPath: join46(".agents", "memories") }
+    nonRootPath = { relativeDirPath: join59(".agents", "memories") }
   }) {
     const params = this.buildToolRuleParamsDefault({
       baseDir,
@@ -4796,7 +6129,7 @@ var ToolRule = class extends ToolFile {
     });
     const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
     if (!rulesyncFrontmatter.root && rulesyncFrontmatter.agentsmd?.subprojectPath) {
-      params.relativeDirPath = join46(rulesyncFrontmatter.agentsmd.subprojectPath);
+      params.relativeDirPath = join59(rulesyncFrontmatter.agentsmd.subprojectPath);
       params.relativeFilePath = "AGENTS.md";
     }
     return params;
@@ -4861,7 +6194,7 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
         relativeFilePath: "AGENTS.md"
       },
       nonRoot: {
-        relativeDirPath: join47(".agents", "memories")
+        relativeDirPath: join60(".agents", "memories")
       }
     };
   }
@@ -4871,8 +6204,8 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join47(".agents", "memories", relativeFilePath);
-    const fileContent = await readFileContent(join47(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : join60(".agents", "memories", relativeFilePath);
+    const fileContent = await readFileContent(join60(baseDir, relativePath));
     return new _AgentsMdRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4912,12 +6245,12 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 };
 
 // src/features/rules/amazonqcli-rule.ts
-import { join as join48 } from "path";
+import { join as join61 } from "path";
 var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
   static getSettablePaths() {
     return {
       nonRoot: {
-        relativeDirPath: join48(".amazonq", "rules")
+        relativeDirPath: join61(".amazonq", "rules")
       }
     };
   }
@@ -4927,7 +6260,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join48(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join61(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _AmazonQCliRule({
       baseDir,
@@ -4967,7 +6300,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 };
 
 // src/features/rules/augmentcode-legacy-rule.ts
-import { join as join49 } from "path";
+import { join as join62 } from "path";
 var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   toRulesyncRule() {
     const rulesyncFrontmatter = {
@@ -4993,7 +6326,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
         relativeFilePath: ".augment-guidelines"
       },
       nonRoot: {
-        relativeDirPath: join49(".augment", "rules")
+        relativeDirPath: join62(".augment", "rules")
       }
     };
   }
@@ -5028,8 +6361,8 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   }) {
     const settablePaths = this.getSettablePaths();
     const isRoot = relativeFilePath === settablePaths.root.relativeFilePath;
-    const relativePath = isRoot ? settablePaths.root.relativeFilePath : join49(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join49(baseDir, relativePath));
+    const relativePath = isRoot ? settablePaths.root.relativeFilePath : join62(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join62(baseDir, relativePath));
     return new _AugmentcodeLegacyRule({
       baseDir,
       relativeDirPath: isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath,
@@ -5042,7 +6375,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
 };
 
 // src/features/rules/augmentcode-rule.ts
-import { join as join50 } from "path";
+import { join as join63 } from "path";
 var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   toRulesyncRule() {
     return this.toRulesyncRuleDefault();
@@ -5050,7 +6383,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   static getSettablePaths() {
     return {
       nonRoot: {
-        relativeDirPath: join50(".augment", "rules")
+        relativeDirPath: join63(".augment", "rules")
       }
     };
   }
@@ -5074,7 +6407,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join50(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join63(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     const { body: content } = parseFrontmatter(fileContent);
     return new _AugmentcodeRule({
@@ -5097,7 +6430,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
 };
 
 // src/features/rules/claudecode-rule.ts
-import { join as join51 } from "path";
+import { join as join64 } from "path";
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   static getSettablePaths({
     global
@@ -5116,7 +6449,7 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
         relativeFilePath: "CLAUDE.md"
       },
       nonRoot: {
-        relativeDirPath: join51(".claude", "memories")
+        relativeDirPath: join64(".claude", "memories")
       }
     };
   }
@@ -5131,7 +6464,7 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
     if (isRoot) {
       const relativePath2 = paths.root.relativeFilePath;
       const fileContent2 = await readFileContent(
-        join51(baseDir, paths.root.relativeDirPath, relativePath2)
+        join64(baseDir, paths.root.relativeDirPath, relativePath2)
       );
       return new _ClaudecodeRule({
         baseDir,
@@ -5145,8 +6478,8 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
     if (!paths.nonRoot) {
       throw new Error("nonRoot path is not set");
     }
-    const relativePath = join51(paths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join51(baseDir, relativePath));
+    const relativePath = join64(paths.nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join64(baseDir, relativePath));
     return new _ClaudecodeRule({
       baseDir,
       relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -5188,10 +6521,10 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 };
 
 // src/features/rules/cline-rule.ts
-import { join as join52 } from "path";
-import { z as z21 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z21.object({
-  description: z21.string()
+import { join as join65 } from "path";
+import { z as z26 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z26.object({
+  description: z26.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -5233,7 +6566,7 @@ var ClineRule = class _ClineRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join52(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join65(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _ClineRule({
       baseDir,
@@ -5246,7 +6579,7 @@ var ClineRule = class _ClineRule extends ToolRule {
 };
 
 // src/features/rules/codexcli-rule.ts
-import { join as join53 } from "path";
+import { join as join66 } from "path";
 var CodexcliRule = class _CodexcliRule extends ToolRule {
   static getSettablePaths({
     global
@@ -5265,7 +6598,7 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
         relativeFilePath: "AGENTS.md"
       },
       nonRoot: {
-        relativeDirPath: join53(".codex", "memories")
+        relativeDirPath: join66(".codex", "memories")
       }
     };
   }
@@ -5280,7 +6613,7 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
     if (isRoot) {
       const relativePath2 = paths.root.relativeFilePath;
       const fileContent2 = await readFileContent(
-        join53(baseDir, paths.root.relativeDirPath, relativePath2)
+        join66(baseDir, paths.root.relativeDirPath, relativePath2)
       );
       return new _CodexcliRule({
         baseDir,
@@ -5294,8 +6627,8 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
     if (!paths.nonRoot) {
       throw new Error("nonRoot path is not set");
     }
-    const relativePath = join53(paths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join53(baseDir, relativePath));
+    const relativePath = join66(paths.nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join66(baseDir, relativePath));
     return new _CodexcliRule({
       baseDir,
       relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -5337,11 +6670,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 };
 
 // src/features/rules/copilot-rule.ts
-import { join as join54 } from "path";
-import { z as z22 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z22.object({
-  description: z22.optional(z22.string()),
-  applyTo: z22.optional(z22.string())
+import { join as join67 } from "path";
+import { z as z27 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z27.object({
+  description: z27.optional(z27.string()),
+  applyTo: z27.optional(z27.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -5353,7 +6686,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
         relativeFilePath: "copilot-instructions.md"
       },
       nonRoot: {
-        relativeDirPath: join54(".github", "instructions")
+        relativeDirPath: join67(".github", "instructions")
       }
     };
   }
@@ -5362,7 +6695,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
       const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join54(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join67(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -5440,11 +6773,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "copilot-instructions.md";
-    const relativePath = isRoot ? join54(
+    const relativePath = isRoot ? join67(
       this.getSettablePaths().root.relativeDirPath,
       this.getSettablePaths().root.relativeFilePath
-    ) : join54(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join54(baseDir, relativePath));
+    ) : join67(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join67(baseDir, relativePath));
     if (isRoot) {
       return new _CopilotRule({
         baseDir,
@@ -5463,7 +6796,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(
-        `Invalid frontmatter in ${join54(baseDir, relativeFilePath)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join67(baseDir, relativeFilePath)}: ${formatError(result.error)}`
       );
     }
     return new _CopilotRule({
@@ -5487,7 +6820,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join54(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join67(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -5507,12 +6840,12 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 };
 
 // src/features/rules/cursor-rule.ts
-import { basename as basename16, join as join55 } from "path";
-import { z as z23 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z23.object({
-  description: z23.optional(z23.string()),
-  globs: z23.optional(z23.string()),
-  alwaysApply: z23.optional(z23.boolean())
+import { basename as basename18, join as join68 } from "path";
+import { z as z28 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z28.object({
+  description: z28.optional(z28.string()),
+  globs: z28.optional(z28.string()),
+  alwaysApply: z28.optional(z28.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -5520,7 +6853,7 @@ var CursorRule = class _CursorRule extends ToolRule {
   static getSettablePaths() {
     return {
       nonRoot: {
-        relativeDirPath: join55(".cursor", "rules")
+        relativeDirPath: join68(".cursor", "rules")
       }
     };
   }
@@ -5529,7 +6862,7 @@ var CursorRule = class _CursorRule extends ToolRule {
       const result = CursorRuleFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join55(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join68(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -5646,19 +6979,19 @@ var CursorRule = class _CursorRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join55(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join68(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     const { frontmatter, body: content } = _CursorRule.parseCursorFrontmatter(fileContent);
     const result = CursorRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(
-        `Invalid frontmatter in ${join55(baseDir, relativeFilePath)}: ${formatError(result.error)}`
+        `Invalid frontmatter in ${join68(baseDir, relativeFilePath)}: ${formatError(result.error)}`
       );
     }
     return new _CursorRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: basename16(relativeFilePath),
+      relativeFilePath: basename18(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -5675,7 +7008,7 @@ var CursorRule = class _CursorRule extends ToolRule {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join55(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join68(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -5695,7 +7028,7 @@ var CursorRule = class _CursorRule extends ToolRule {
 };
 
 // src/features/rules/geminicli-rule.ts
-import { join as join56 } from "path";
+import { join as join69 } from "path";
 var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   static getSettablePaths({
     global
@@ -5714,7 +7047,7 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
         relativeFilePath: "GEMINI.md"
       },
       nonRoot: {
-        relativeDirPath: join56(".gemini", "memories")
+        relativeDirPath: join69(".gemini", "memories")
       }
     };
   }
@@ -5729,7 +7062,7 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
     if (isRoot) {
       const relativePath2 = paths.root.relativeFilePath;
       const fileContent2 = await readFileContent(
-        join56(baseDir, paths.root.relativeDirPath, relativePath2)
+        join69(baseDir, paths.root.relativeDirPath, relativePath2)
       );
       return new _GeminiCliRule({
         baseDir,
@@ -5743,8 +7076,8 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
     if (!paths.nonRoot) {
       throw new Error("nonRoot path is not set");
     }
-    const relativePath = join56(paths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join56(baseDir, relativePath));
+    const relativePath = join69(paths.nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join69(baseDir, relativePath));
     return new _GeminiCliRule({
       baseDir,
       relativeDirPath: paths.nonRoot.relativeDirPath,
@@ -5786,7 +7119,7 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
 };
 
 // src/features/rules/junie-rule.ts
-import { join as join57 } from "path";
+import { join as join70 } from "path";
 var JunieRule = class _JunieRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -5795,7 +7128,7 @@ var JunieRule = class _JunieRule extends ToolRule {
         relativeFilePath: "guidelines.md"
       },
       nonRoot: {
-        relativeDirPath: join57(".junie", "memories")
+        relativeDirPath: join70(".junie", "memories")
       }
     };
   }
@@ -5805,8 +7138,8 @@ var JunieRule = class _JunieRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "guidelines.md";
-    const relativePath = isRoot ? "guidelines.md" : join57(".junie", "memories", relativeFilePath);
-    const fileContent = await readFileContent(join57(baseDir, relativePath));
+    const relativePath = isRoot ? "guidelines.md" : join70(".junie", "memories", relativeFilePath);
+    const fileContent = await readFileContent(join70(baseDir, relativePath));
     return new _JunieRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -5846,12 +7179,12 @@ var JunieRule = class _JunieRule extends ToolRule {
 };
 
 // src/features/rules/kiro-rule.ts
-import { join as join58 } from "path";
+import { join as join71 } from "path";
 var KiroRule = class _KiroRule extends ToolRule {
   static getSettablePaths() {
     return {
       nonRoot: {
-        relativeDirPath: join58(".kiro", "steering")
+        relativeDirPath: join71(".kiro", "steering")
       }
     };
   }
@@ -5861,7 +7194,7 @@ var KiroRule = class _KiroRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join58(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join71(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _KiroRule({
       baseDir,
@@ -5901,7 +7234,7 @@ var KiroRule = class _KiroRule extends ToolRule {
 };
 
 // src/features/rules/opencode-rule.ts
-import { join as join59 } from "path";
+import { join as join72 } from "path";
 var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -5910,7 +7243,7 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
         relativeFilePath: "AGENTS.md"
       },
       nonRoot: {
-        relativeDirPath: join59(".opencode", "memories")
+        relativeDirPath: join72(".opencode", "memories")
       }
     };
   }
@@ -5920,8 +7253,8 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join59(".opencode", "memories", relativeFilePath);
-    const fileContent = await readFileContent(join59(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : join72(".opencode", "memories", relativeFilePath);
+    const fileContent = await readFileContent(join72(baseDir, relativePath));
     return new _OpenCodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -5961,7 +7294,7 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
 };
 
 // src/features/rules/qwencode-rule.ts
-import { join as join60 } from "path";
+import { join as join73 } from "path";
 var QwencodeRule = class _QwencodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -5970,7 +7303,7 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
         relativeFilePath: "QWEN.md"
       },
       nonRoot: {
-        relativeDirPath: join60(".qwen", "memories")
+        relativeDirPath: join73(".qwen", "memories")
       }
     };
   }
@@ -5980,8 +7313,8 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "QWEN.md";
-    const relativePath = isRoot ? "QWEN.md" : join60(".qwen", "memories", relativeFilePath);
-    const fileContent = await readFileContent(join60(baseDir, relativePath));
+    const relativePath = isRoot ? "QWEN.md" : join73(".qwen", "memories", relativeFilePath);
+    const fileContent = await readFileContent(join73(baseDir, relativePath));
     return new _QwencodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -6018,12 +7351,12 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
 };
 
 // src/features/rules/roo-rule.ts
-import { join as join61 } from "path";
+import { join as join74 } from "path";
 var RooRule = class _RooRule extends ToolRule {
   static getSettablePaths() {
     return {
       nonRoot: {
-        relativeDirPath: join61(".roo", "rules")
+        relativeDirPath: join74(".roo", "rules")
       }
     };
   }
@@ -6033,7 +7366,7 @@ var RooRule = class _RooRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join61(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join74(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _RooRule({
       baseDir,
@@ -6088,7 +7421,7 @@ var RooRule = class _RooRule extends ToolRule {
 };
 
 // src/features/rules/warp-rule.ts
-import { join as join62 } from "path";
+import { join as join75 } from "path";
 var WarpRule = class _WarpRule extends ToolRule {
   constructor({ fileContent, root, ...rest }) {
     super({
@@ -6104,7 +7437,7 @@ var WarpRule = class _WarpRule extends ToolRule {
         relativeFilePath: "WARP.md"
       },
       nonRoot: {
-        relativeDirPath: join62(".warp", "memories")
+        relativeDirPath: join75(".warp", "memories")
       }
     };
   }
@@ -6114,8 +7447,8 @@ var WarpRule = class _WarpRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join62(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join62(baseDir, relativePath));
+    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join75(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join75(baseDir, relativePath));
     return new _WarpRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : ".warp",
@@ -6155,12 +7488,12 @@ var WarpRule = class _WarpRule extends ToolRule {
 };
 
 // src/features/rules/windsurf-rule.ts
-import { join as join63 } from "path";
+import { join as join76 } from "path";
 var WindsurfRule = class _WindsurfRule extends ToolRule {
   static getSettablePaths() {
     return {
       nonRoot: {
-        relativeDirPath: join63(".windsurf", "rules")
+        relativeDirPath: join76(".windsurf", "rules")
       }
     };
   }
@@ -6170,7 +7503,7 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join63(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join76(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _WindsurfRule({
       baseDir,
@@ -6228,7 +7561,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z24.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z29.enum(rulesProcessorToolTargets);
 var rulesProcessorToolTargetsGlobal = [
   "claudecode",
   "codexcli",
@@ -6238,12 +7571,14 @@ var RulesProcessor = class extends FeatureProcessor {
   toolTarget;
   simulateCommands;
   simulateSubagents;
+  simulateSkills;
   global;
   constructor({
     baseDir = process.cwd(),
     toolTarget,
     simulateCommands = false,
     simulateSubagents = false,
+    simulateSkills = false,
     global = false
   }) {
     super({ baseDir });
@@ -6257,6 +7592,7 @@ var RulesProcessor = class extends FeatureProcessor {
     this.global = global;
     this.simulateCommands = simulateCommands;
     this.simulateSubagents = simulateSubagents;
+    this.simulateSkills = simulateSkills;
   }
   async convertRulesyncFilesToToolFiles(rulesyncFiles) {
     const rulesyncRules = rulesyncFiles.filter(
@@ -6424,7 +7760,7 @@ var RulesProcessor = class extends FeatureProcessor {
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
     }).filter((rule) => rule !== null);
-    const isSimulated = this.simulateCommands || this.simulateSubagents;
+    const isSimulated = this.simulateCommands || this.simulateSubagents || this.simulateSkills;
     if (isSimulated && this.toolTarget === "cursor") {
       toolRules.push(
         new CursorRule({
@@ -6436,6 +7772,9 @@ var RulesProcessor = class extends FeatureProcessor {
             commands: { relativeDirPath: CursorCommand.getSettablePaths().relativeDirPath },
             subagents: {
               relativeDirPath: CursorSubagent.getSettablePaths().relativeDirPath
+            },
+            skills: {
+              relativeDirPath: CursorSkill.getSettablePaths().relativeDirPath
             }
           }),
           relativeDirPath: CursorRule.getSettablePaths().nonRoot.relativeDirPath,
@@ -6497,6 +7836,9 @@ var RulesProcessor = class extends FeatureProcessor {
           this.generateXmlReferencesSection(toolRules) + this.generateAdditionalConventionsSection({
             subagents: {
               relativeDirPath: CodexCliSubagent.getSettablePaths().relativeDirPath
+            },
+            skills: {
+              relativeDirPath: CodexCliSkill.getSettablePaths().relativeDirPath
             }
           }) + rootRule.getFileContent()
         );
@@ -6509,6 +7851,9 @@ var RulesProcessor = class extends FeatureProcessor {
             commands: { relativeDirPath: CopilotCommand.getSettablePaths().relativeDirPath },
             subagents: {
               relativeDirPath: CopilotSubagent.getSettablePaths().relativeDirPath
+            },
+            skills: {
+              relativeDirPath: CopilotSkill.getSettablePaths().relativeDirPath
             }
           }) + rootRule.getFileContent()
         );
@@ -6570,10 +7915,10 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    const files = await findFilesByGlobs(join64(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md"));
+    const files = await findFilesByGlobs(join77(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md"));
     logger.debug(`Found ${files.length} rulesync files`);
     const rulesyncRules = await Promise.all(
-      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename17(file) }))
+      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename19(file) }))
     );
     const rootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().root);
     if (rootRules.length > 1) {
@@ -6591,17 +7936,19 @@ var RulesProcessor = class extends FeatureProcessor {
     return rulesyncRules;
   }
   async loadRulesyncFilesLegacy() {
-    const legacyFiles = await findFilesByGlobs(join64(RULESYNC_RELATIVE_DIR_PATH, "*.md"));
+    const legacyFiles = await findFilesByGlobs(join77(RULESYNC_RELATIVE_DIR_PATH, "*.md"));
     logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
     return Promise.all(
-      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename17(file) }))
+      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename19(file) }))
     );
   }
   /**
    * Implementation of abstract method from FeatureProcessor
    * Load tool-specific rule configurations and parse them into ToolRule instances
    */
-  async loadToolFiles() {
+  async loadToolFiles({
+    forDeletion: _forDeletion = false
+  } = {}) {
     try {
       switch (this.toolTarget) {
         case "agentsmd":
@@ -6646,9 +7993,6 @@ var RulesProcessor = class extends FeatureProcessor {
       return [];
     }
   }
-  async loadToolFilesToDelete() {
-    return this.loadToolFiles();
-  }
   async loadToolRulesDefault({
     root,
     nonRoot
@@ -6658,13 +8002,13 @@ var RulesProcessor = class extends FeatureProcessor {
         return [];
       }
       const rootFilePaths = await findFilesByGlobs(
-        join64(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
+        join77(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
       );
       return await Promise.all(
         rootFilePaths.map(
           (filePath) => root.fromFile({
             baseDir: this.baseDir,
-            relativeFilePath: basename17(filePath),
+            relativeFilePath: basename19(filePath),
             global: this.global
           })
         )
@@ -6676,13 +8020,13 @@ var RulesProcessor = class extends FeatureProcessor {
         return [];
       }
       const nonRootFilePaths = await findFilesByGlobs(
-        join64(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
+        join77(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
       );
       return await Promise.all(
         nonRootFilePaths.map(
           (filePath) => nonRoot.fromFile({
             baseDir: this.baseDir,
-            relativeFilePath: basename17(filePath),
+            relativeFilePath: basename19(filePath),
             global: this.global
           })
         )
@@ -6969,12 +8313,12 @@ var RulesProcessor = class extends FeatureProcessor {
    * Implementation of abstract method from FeatureProcessor
    * Return the tool targets that this processor supports
    */
-  static getToolTargets() {
+  static getToolTargets({ global = false } = {}) {
+    if (global) {
+      return rulesProcessorToolTargetsGlobal;
+    }
     return rulesProcessorToolTargets;
   }
-  static getToolTargetsGlobal() {
-    return rulesProcessorToolTargetsGlobal;
-  }
   generateXmlReferencesSection(toolRules) {
     const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
     if (toolRulesWithoutRoot.length === 0) {
@@ -7032,7 +8376,8 @@ var RulesProcessor = class extends FeatureProcessor {
   }
   generateAdditionalConventionsSection({
     commands,
-    subagents
+    subagents,
+    skills
   }) {
     const overview = `# Additional Conventions Beyond the Built-in Functions
 
@@ -7049,21 +8394,31 @@ Users can use following syntax to invoke a custom command.
 s/<command> [arguments]
 \`\`\`
 
-This syntax employs a double slash (\`s/\`) to prevent conflicts with built-in slash commands.  
+This syntax employs a double slash (\`s/\`) to prevent conflicts with built-in slash commands.
 The \`s\` in \`s/\` stands for *simulate*. Because custom slash commands are not built-in, this syntax provides a pseudo way to invoke them.
 
-When users call a custom slash command, you have to look for the markdown file, \`${join64(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "{command}.md")}\`, then execute the contents of that file as the block of operations.` : "";
+When users call a custom slash command, you have to look for the markdown file, \`${join77(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "{command}.md")}\`, then execute the contents of that file as the block of operations.` : "";
     const subagentsSection = subagents ? `## Simulated Subagents
 
 Simulated subagents are specialized AI assistants that can be invoked to handle specific types of tasks. In this case, it can be appear something like custom slash commands simply. Simulated subagents can be called by custom slash commands.
 
-When users call a simulated subagent, it will look for the corresponding markdown file, \`${join64(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "{subagent}.md")}\`, and execute its contents as the block of operations.
+When users call a simulated subagent, it will look for the corresponding markdown file, \`${join77(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, \`${join64(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "planner.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, \`${join77(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 \`${join77(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 \`${join77(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 result = [
       overview,
       ...this.simulateCommands && CommandsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [commandsSection] : [],
-      ...this.simulateSubagents && SubagentsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [subagentsSection] : []
+      ...this.simulateSubagents && SubagentsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [subagentsSection] : [],
+      ...this.simulateSkills && SkillsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [skillsSection] : []
     ].join("\n\n") + "\n\n";
     return result;
   }
@@ -7084,7 +8439,8 @@ async function generateCommand(options) {
   const totalMcpOutputs = await generateMcp(config);
   const totalCommandOutputs = await generateCommands(config);
   const totalSubagentOutputs = await generateSubagents(config);
-  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs;
+  const totalSkillOutputs = await generateSkills(config);
+  const totalGenerated = totalRulesOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs + totalSkillOutputs;
   if (totalGenerated === 0) {
     const enabledFeatures = config.getFeatures().join(", ");
     logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
@@ -7097,6 +8453,7 @@ 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`);
     logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   }
 }
@@ -7107,18 +8464,22 @@ async function generateRules(config) {
   }
   let totalRulesOutputs = 0;
   logger.info("Generating rule files...");
-  const toolTargets = config.getGlobal() ? intersection(config.getTargets(), RulesProcessor.getToolTargetsGlobal()) : intersection(config.getTargets(), RulesProcessor.getToolTargets());
+  const toolTargets = intersection(
+    config.getTargets(),
+    RulesProcessor.getToolTargets({ global: config.getGlobal() })
+  );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       const processor = new RulesProcessor({
         baseDir,
         toolTarget,
         global: config.getGlobal(),
-        simulateCommands: config.getSimulatedCommands(),
-        simulateSubagents: config.getSimulatedSubagents()
+        simulateCommands: config.getSimulateCommands(),
+        simulateSubagents: config.getSimulateSubagents(),
+        simulateSkills: config.getSimulateSkills()
       });
       if (config.getDelete()) {
-        const oldToolFiles = await processor.loadToolFilesToDelete();
+        const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
         await processor.removeAiFiles(oldToolFiles);
       }
       let rulesyncFiles = await processor.loadRulesyncFiles();
@@ -7152,7 +8513,7 @@ async function generateIgnore(config) {
           toolTarget
         });
         if (config.getDelete()) {
-          const oldToolFiles = await processor.loadToolFilesToDelete();
+          const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
           await processor.removeAiFiles(oldToolFiles);
         }
         const rulesyncFiles = await processor.loadRulesyncFiles();
@@ -7183,7 +8544,10 @@ async function generateMcp(config) {
   if (config.getModularMcp()) {
     logger.info("\u2139\uFE0F  Modular MCP support is experimental.");
   }
-  const toolTargets = config.getGlobal() ? intersection(config.getTargets(), McpProcessor.getToolTargetsGlobal()) : intersection(config.getTargets(), McpProcessor.getToolTargets());
+  const toolTargets = intersection(
+    config.getTargets(),
+    McpProcessor.getToolTargets({ global: config.getGlobal() })
+  );
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       const processor = new McpProcessor({
@@ -7193,7 +8557,7 @@ async function generateMcp(config) {
         modularMcp: config.getModularMcp()
       });
       if (config.getDelete()) {
-        const oldToolFiles = await processor.loadToolFilesToDelete();
+        const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
         await processor.removeAiFiles(oldToolFiles);
       }
       const rulesyncFiles = await processor.loadRulesyncFiles();
@@ -7212,10 +8576,11 @@ async function generateCommands(config) {
   }
   let totalCommandOutputs = 0;
   logger.info("Generating command files...");
-  const toolTargets = config.getGlobal() ? intersection(config.getTargets(), CommandsProcessor.getToolTargetsGlobal()) : intersection(
+  const toolTargets = intersection(
     config.getTargets(),
     CommandsProcessor.getToolTargets({
-      includeSimulated: config.getSimulatedCommands()
+      global: config.getGlobal(),
+      includeSimulated: config.getSimulateCommands()
     })
   );
   for (const baseDir of config.getBaseDirs()) {
@@ -7226,7 +8591,7 @@ async function generateCommands(config) {
         global: config.getGlobal()
       });
       if (config.getDelete()) {
-        const oldToolFiles = await processor.loadToolFilesToDelete();
+        const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
         await processor.removeAiFiles(oldToolFiles);
       }
       const rulesyncFiles = await processor.loadRulesyncFiles();
@@ -7245,10 +8610,11 @@ async function generateSubagents(config) {
   }
   let totalSubagentOutputs = 0;
   logger.info("Generating subagent files...");
-  const toolTargets = config.getGlobal() ? intersection(config.getTargets(), SubagentsProcessor.getToolTargetsGlobal()) : intersection(
+  const toolTargets = intersection(
     config.getTargets(),
     SubagentsProcessor.getToolTargets({
-      includeSimulated: config.getSimulatedSubagents()
+      global: config.getGlobal(),
+      includeSimulated: config.getSimulateSubagents()
     })
   );
   for (const baseDir of config.getBaseDirs()) {
@@ -7259,7 +8625,7 @@ async function generateSubagents(config) {
         global: config.getGlobal()
       });
       if (config.getDelete()) {
-        const oldToolFiles = await processor.loadToolFilesToDelete();
+        const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
         await processor.removeAiFiles(oldToolFiles);
       }
       const rulesyncFiles = await processor.loadRulesyncFiles();
@@ -7271,16 +8637,51 @@ async function generateSubagents(config) {
   }
   return totalSubagentOutputs;
 }
+async function generateSkills(config) {
+  if (!config.getFeatures().includes("skills")) {
+    logger.debug("Skipping skill generation (not in --features)");
+    return 0;
+  }
+  let totalSkillOutputs = 0;
+  logger.info("Generating skill files...");
+  const toolTargets = intersection(
+    config.getTargets(),
+    SkillsProcessor.getToolTargets({
+      global: config.getGlobal(),
+      includeSimulated: config.getSimulateSkills()
+    })
+  );
+  for (const baseDir of config.getBaseDirs()) {
+    for (const toolTarget of toolTargets) {
+      const processor = new SkillsProcessor({
+        baseDir,
+        toolTarget,
+        global: config.getGlobal()
+      });
+      if (config.getDelete()) {
+        const oldToolDirs = await processor.loadToolDirsToDelete();
+        await processor.removeAiDirs(oldToolDirs);
+      }
+      const rulesyncDirs = await processor.loadRulesyncDirs();
+      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;
+}
 
 // src/cli/commands/gitignore.ts
-import { join as join65 } from "path";
+import { join as join78 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join65(process.cwd(), ".gitignore");
+  const gitignorePath = join78(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     // AGENTS.md
     "**/AGENTS.md",
     "**/.agents/",
+    "**/.agents/skills/",
     // Amazon Q
     "**/.amazonq/",
     // Augment
@@ -7292,6 +8693,7 @@ var gitignoreCommand = async () => {
     "**/.claude/memories/",
     "**/.claude/commands/",
     "**/.claude/agents/",
+    "**/.claude/skills/",
     "**/.claude/settings.local.json",
     "**/.mcp.json",
     // Cline
@@ -7301,20 +8703,25 @@ var gitignoreCommand = async () => {
     // Codex
     "**/.codexignore",
     "**/.codex/",
+    "**/.codex/skills/",
     // Cursor
     "**/.cursor/",
     "**/.cursorignore",
     "**/.cursor/mcp.json",
+    "**/.cursor/subagents/",
+    "**/.cursor/skills/",
     // Gemini
     "**/GEMINI.md",
     "**/.gemini/memories/",
     "**/.gemini/commands/",
     "**/.gemini/subagents/",
+    "**/.gemini/skills/",
     // GitHub Copilot
     "**/.github/copilot-instructions.md",
     "**/.github/instructions/",
     "**/.github/prompts/",
     "**/.github/subagents/",
+    "**/.github/skills/",
     "**/.vscode/mcp.json",
     // Junie
     "**/.junie/guidelines.md",
@@ -7385,13 +8792,14 @@ async function importCommand(options) {
   await importMcp(config, tool);
   await importCommands(config, tool);
   await importSubagents(config, tool);
+  await importSkills(config, tool);
 }
 async function importRules(config, tool) {
   if (!config.getFeatures().includes("rules")) {
     return 0;
   }
   const global = config.getGlobal();
-  const supportedTargets = global ? RulesProcessor.getToolTargetsGlobal() : RulesProcessor.getToolTargets();
+  const supportedTargets = RulesProcessor.getToolTargets({ global });
   if (!supportedTargets.includes(tool)) {
     return 0;
   }
@@ -7445,7 +8853,7 @@ async function importMcp(config, tool) {
     return 0;
   }
   const global = config.getGlobal();
-  const supportedTargets = global ? McpProcessor.getToolTargetsGlobal() : McpProcessor.getToolTargets();
+  const supportedTargets = McpProcessor.getToolTargets({ global });
   if (!supportedTargets.includes(tool)) {
     return 0;
   }
@@ -7470,7 +8878,7 @@ async function importCommands(config, tool) {
     return 0;
   }
   const global = config.getGlobal();
-  const supportedTargets = global ? CommandsProcessor.getToolTargetsGlobal() : CommandsProcessor.getToolTargets({ includeSimulated: false });
+  const supportedTargets = CommandsProcessor.getToolTargets({ global, includeSimulated: false });
   if (!supportedTargets.includes(tool)) {
     return 0;
   }
@@ -7494,7 +8902,8 @@ async function importSubagents(config, tool) {
   if (!config.getFeatures().includes("subagents")) {
     return 0;
   }
-  const supportedTargets = SubagentsProcessor.getToolTargets({ includeSimulated: false });
+  const global = config.getGlobal();
+  const supportedTargets = SubagentsProcessor.getToolTargets({ global, includeSimulated: false });
   if (!supportedTargets.includes(tool)) {
     return 0;
   }
@@ -7514,9 +8923,34 @@ async function importSubagents(config, tool) {
   }
   return writtenCount;
 }
+async function importSkills(config, tool) {
+  if (!config.getFeatures().includes("skills")) {
+    return 0;
+  }
+  const global = config.getGlobal();
+  const supportedTargets = SkillsProcessor.getToolTargets({ global });
+  if (!supportedTargets.includes(tool)) {
+    return 0;
+  }
+  const skillsProcessor = new SkillsProcessor({
+    baseDir: config.getBaseDirs()[0] ?? ".",
+    toolTarget: tool,
+    global
+  });
+  const toolDirs = await skillsProcessor.loadToolDirs();
+  if (toolDirs.length === 0) {
+    return 0;
+  }
+  const rulesyncDirs = await skillsProcessor.convertToolDirsToRulesyncDirs(toolDirs);
+  const writtenCount = await skillsProcessor.writeAiDirs(rulesyncDirs);
+  if (config.getVerbose() && writtenCount > 0) {
+    logger.success(`Created ${writtenCount} skill directories`);
+  }
+  return writtenCount;
+}
 
 // src/cli/commands/init.ts
-import { join as join66 } from "path";
+import { join as join79 } from "path";
 async function initCommand() {
   logger.info("Initializing rulesync...");
   await ensureDir(RULESYNC_RELATIVE_DIR_PATH);
@@ -7544,8 +8978,8 @@ async function createConfigFile() {
         delete: true,
         verbose: false,
         global: false,
-        simulatedCommands: false,
-        simulatedSubagents: false,
+        simulateCommands: false,
+        simulateSubagents: false,
         modularMcp: false
       },
       null,
@@ -7679,14 +9113,14 @@ Attention, again, you are just the planner, so though you can read any files and
   await ensureDir(commandPaths.relativeDirPath);
   await ensureDir(subagentPaths.relativeDirPath);
   await ensureDir(ignorePaths.relativeDirPath);
-  const ruleFilepath = join66(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = join79(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   if (!await fileExists(ruleFilepath)) {
     await writeFileContent(ruleFilepath, sampleRuleFile.content);
     logger.success(`Created ${ruleFilepath}`);
   } else {
     logger.info(`Skipped ${ruleFilepath} (already exists)`);
   }
-  const mcpFilepath = join66(
+  const mcpFilepath = join79(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
@@ -7696,21 +9130,21 @@ Attention, again, you are just the planner, so though you can read any files and
   } else {
     logger.info(`Skipped ${mcpFilepath} (already exists)`);
   }
-  const commandFilepath = join66(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = join79(commandPaths.relativeDirPath, sampleCommandFile.filename);
   if (!await fileExists(commandFilepath)) {
     await writeFileContent(commandFilepath, sampleCommandFile.content);
     logger.success(`Created ${commandFilepath}`);
   } else {
     logger.info(`Skipped ${commandFilepath} (already exists)`);
   }
-  const subagentFilepath = join66(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = join79(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   if (!await fileExists(subagentFilepath)) {
     await writeFileContent(subagentFilepath, sampleSubagentFile.content);
     logger.success(`Created ${subagentFilepath}`);
   } else {
     logger.info(`Skipped ${subagentFilepath} (already exists)`);
   }
-  const ignoreFilepath = join66(ignorePaths.relativeDirPath, ignorePaths.relativeFilePath);
+  const ignoreFilepath = join79(ignorePaths.relativeDirPath, ignorePaths.relativeFilePath);
   if (!await fileExists(ignoreFilepath)) {
     await writeFileContent(ignoreFilepath, sampleIgnoreFile.content);
     logger.success(`Created ${ignoreFilepath}`);
@@ -7723,12 +9157,12 @@ Attention, again, you are just the planner, so though you can read any files and
 import { FastMCP } from "fastmcp";
 
 // src/mcp/commands.ts
-import { basename as basename18, join as join67 } from "path";
-import { z as z25 } from "zod/mini";
+import { basename as basename20, join as join80 } from "path";
+import { z as z30 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = join67(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = join80(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -7740,7 +9174,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join80(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -7760,13 +9194,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename18(relativePathFromCwd);
+  const filename = basename20(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join80(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -7785,7 +9219,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename18(relativePathFromCwd);
+  const filename = basename20(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -7795,7 +9229,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === join80(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(`Maximum number of commands (${maxCommandsCount}) reached`);
@@ -7810,11 +9244,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = join67(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = join80(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join80(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -7829,12 +9263,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename18(relativePathFromCwd);
-  const fullPath = join67(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = basename20(relativePathFromCwd);
+  const fullPath = join80(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join80(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -7843,23 +9277,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: z25.object({}),
-  getCommand: z25.object({
-    relativePathFromCwd: z25.string()
+  listCommands: z30.object({}),
+  getCommand: z30.object({
+    relativePathFromCwd: z30.string()
   }),
-  putCommand: z25.object({
-    relativePathFromCwd: z25.string(),
+  putCommand: z30.object({
+    relativePathFromCwd: z30.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: z25.string()
+    body: z30.string()
   }),
-  deleteCommand: z25.object({
-    relativePathFromCwd: z25.string()
+  deleteCommand: z30.object({
+    relativePathFromCwd: z30.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${join67(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${join80(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -7901,11 +9335,11 @@ var commandTools = {
 };
 
 // src/mcp/ignore.ts
-import { join as join68 } from "path";
-import { z as z26 } from "zod/mini";
+import { join as join81 } from "path";
+import { z as z31 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = join68(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join81(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -7919,7 +9353,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = join68(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join81(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -7940,7 +9374,7 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const ignoreFilePath = join68(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = join81(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await removeFile(ignoreFilePath);
     return {
@@ -7953,11 +9387,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z26.object({}),
-  putIgnoreFile: z26.object({
-    content: z26.string()
+  getIgnoreFile: z31.object({}),
+  putIgnoreFile: z31.object({
+    content: z31.string()
   }),
-  deleteIgnoreFile: z26.object({})
+  deleteIgnoreFile: z31.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -7990,8 +9424,8 @@ var ignoreTools = {
 };
 
 // src/mcp/mcp.ts
-import { join as join69 } from "path";
-import { z as z27 } from "zod/mini";
+import { join as join82 } from "path";
+import { z as z32 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -8000,7 +9434,7 @@ async function getMcpFile() {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    const relativePathFromCwd = join69(
+    const relativePathFromCwd = join82(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -8033,7 +9467,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = join69(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = join82(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -8042,9 +9476,9 @@ async function putMcpFile({ content }) {
       validate: true,
       modularMcp: config.getModularMcp()
     });
-    await ensureDir(join69(baseDir, relativeDirPath));
+    await ensureDir(join82(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = join69(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = join82(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -8059,15 +9493,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = join69(
+    const recommendedPath = join82(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = join69(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = join82(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = join69(
+    const relativePathFromCwd = join82(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -8081,11 +9515,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z27.object({}),
-  putMcpFile: z27.object({
-    content: z27.string()
+  getMcpFile: z32.object({}),
+  putMcpFile: z32.object({
+    content: z32.string()
   }),
-  deleteMcpFile: z27.object({})
+  deleteMcpFile: z32.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -8118,12 +9552,12 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-import { basename as basename19, join as join70 } from "path";
-import { z as z28 } from "zod/mini";
+import { basename as basename21, join as join83 } from "path";
+import { z as z33 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = join70(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = join83(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -8136,7 +9570,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join83(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -8156,14 +9590,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename19(relativePathFromCwd);
+  const filename = basename21(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join83(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -8182,7 +9616,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename19(relativePathFromCwd);
+  const filename = basename21(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -8192,7 +9626,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === join83(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(`Maximum number of rules (${maxRulesCount}) reached`);
@@ -8205,11 +9639,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = join70(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = join83(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join83(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -8224,12 +9658,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename19(relativePathFromCwd);
-  const fullPath = join70(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = basename21(relativePathFromCwd);
+  const fullPath = join83(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join70(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join83(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -8238,23 +9672,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z28.object({}),
-  getRule: z28.object({
-    relativePathFromCwd: z28.string()
+  listRules: z33.object({}),
+  getRule: z33.object({
+    relativePathFromCwd: z33.string()
   }),
-  putRule: z28.object({
-    relativePathFromCwd: z28.string(),
+  putRule: z33.object({
+    relativePathFromCwd: z33.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z28.string()
+    body: z33.string()
   }),
-  deleteRule: z28.object({
-    relativePathFromCwd: z28.string()
+  deleteRule: z33.object({
+    relativePathFromCwd: z33.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${join70(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${join83(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -8296,12 +9730,12 @@ var ruleTools = {
 };
 
 // src/mcp/subagents.ts
-import { basename as basename20, join as join71 } from "path";
-import { z as z29 } from "zod/mini";
+import { basename as basename22, join as join84 } from "path";
+import { z as z34 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = join71(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = join84(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -8314,7 +9748,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: join84(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -8336,14 +9770,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename20(relativePathFromCwd);
+  const filename = basename22(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join84(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -8362,7 +9796,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename20(relativePathFromCwd);
+  const filename = basename22(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -8372,7 +9806,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === join84(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(`Maximum number of subagents (${maxSubagentsCount}) reached`);
@@ -8385,11 +9819,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = join71(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = join84(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: join84(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -8404,12 +9838,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename20(relativePathFromCwd);
-  const fullPath = join71(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = basename22(relativePathFromCwd);
+  const fullPath = join84(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: join84(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -8421,23 +9855,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z29.object({}),
-  getSubagent: z29.object({
-    relativePathFromCwd: z29.string()
+  listSubagents: z34.object({}),
+  getSubagent: z34.object({
+    relativePathFromCwd: z34.string()
   }),
-  putSubagent: z29.object({
-    relativePathFromCwd: z29.string(),
+  putSubagent: z34.object({
+    relativePathFromCwd: z34.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z29.string()
+    body: z34.string()
   }),
-  deleteSubagent: z29.object({
-    relativePathFromCwd: z29.string()
+  deleteSubagent: z34.object({
+    relativePathFromCwd: z34.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${join71(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${join84(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -8511,7 +9945,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.23.6";
+var getVersion = () => "3.25.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();
@@ -8577,20 +10011,23 @@ var main = async () => {
     "-b, --base-dir <paths>",
     "Base directories to generate files (comma-separated for multiple paths)"
   ).option("-V, --verbose", "Verbose output").option("-c, --config <path>", "Path to configuration file").option("-g, --global", "Generate for global(user scope) configuration files").option(
-    "--simulated-commands",
+    "--simulate-commands",
     "Generate simulated commands. This feature is only available for copilot, cursor and codexcli."
   ).option(
-    "--simulated-subagents",
+    "--simulate-subagents",
     "Generate simulated subagents. This feature is only available for copilot, cursor and codexcli."
+  ).option(
+    "--simulate-skills",
+    "Generate simulated skills. This feature is only available for copilot, cursor and codexcli."
   ).option(
     "--experimental-global",
     "Generate for global(user scope) configuration files (deprecated: use --global instead)"
   ).option(
     "--experimental-simulate-commands",
-    "Generate simulated commands (deprecated: use --simulated-commands instead)"
+    "Generate simulated commands (deprecated: use --simulate-commands instead)"
   ).option(
     "--experimental-simulate-subagents",
-    "Generate simulated subagents (deprecated: use --simulated-subagents instead)"
+    "Generate simulated subagents (deprecated: use --simulate-subagents instead)"
   ).option(
     "--modular-mcp",
     "Generate modular-mcp configuration for context compression (experimental)"
@@ -8604,8 +10041,9 @@ var main = async () => {
         baseDirs: options.baseDirs,
         configPath: options.config,
         global: options.global,
-        simulatedCommands: options.simulatedCommands,
-        simulatedSubagents: options.simulatedSubagents,
+        simulateCommands: options.simulateCommands,
+        simulateSubagents: options.simulateSubagents,
+        simulateSkills: options.simulateSkills,
         modularMcp: options.modularMcp,
         experimentalGlobal: options.experimentalGlobal,
         experimentalSimulateCommands: options.experimentalSimulateCommands,