rulesync 0.75.0 → 0.76.0

package/dist/index.js

@@ -742,7 +742,7 @@ import { basename as basename6, join as join6 } from "path";
 var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
   static getSettablePaths() {
     return {
-      relativeDirPath: ".copilot/commands"
+      relativeDirPath: ".github/commands"
     };
   }
   static fromRulesyncCommand({
@@ -1300,6 +1300,9 @@ var CommandsProcessor = class extends FeatureProcessor {
     }
     return commandsProcessorToolTargets;
   }
+  static getToolTargetsSimulated() {
+    return commandsProcessorToolTargetsSimulated;
+  }
 };
 
 // src/config/config-resolver.ts
@@ -2777,9 +2780,9 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/rules/rules-processor.ts
-import { basename as basename14, join as join49 } from "path";
+import { basename as basename16, join as join52 } from "path";
 import { XMLBuilder } from "fast-xml-parser";
-import { z as z17 } from "zod/mini";
+import { z as z20 } from "zod/mini";
 
 // src/constants/paths.ts
 import { join as join29 } from "path";
@@ -2937,7 +2940,7 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
 var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: ".copilot/subagents"
+      relativeDirPath: ".github/subagents"
     };
   }
   static async fromFile(params) {
@@ -2979,189 +2982,686 @@ var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
   }
 };
 
-// src/rules/agentsmd-rule.ts
+// src/subagents/geminicli-subagent.ts
+var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".gemini/subagents"
+    };
+  }
+  static async fromFile(params) {
+    const baseParams = await this.fromFileDefault(params);
+    return new _GeminiCliSubagent(baseParams);
+  }
+  static fromRulesyncSubagent(params) {
+    const baseParams = this.fromRulesyncSubagentDefault(params);
+    return new _GeminiCliSubagent(baseParams);
+  }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "geminicli"
+    });
+  }
+};
+
+// src/subagents/roo-subagent.ts
+var RooSubagent = class _RooSubagent extends SimulatedSubagent {
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".roo/subagents"
+    };
+  }
+  static async fromFile(params) {
+    const baseParams = await this.fromFileDefault(params);
+    return new _RooSubagent(baseParams);
+  }
+  static fromRulesyncSubagent(params) {
+    const baseParams = this.fromRulesyncSubagentDefault(params);
+    return new _RooSubagent(baseParams);
+  }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "roo"
+    });
+  }
+};
+
+// src/subagents/subagents-processor.ts
+import { basename as basename13, join as join33 } from "path";
+import { z as z15 } from "zod/mini";
+
+// src/subagents/claudecode-subagent.ts
 import { join as join32 } from "path";
+import { z as z14 } from "zod/mini";
 
-// src/rules/rulesync-rule.ts
+// src/subagents/rulesync-subagent.ts
 import { basename as basename12, join as join31 } from "path";
 import { z as z13 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z13.object({
-  root: z13.optional(z13.optional(z13.boolean())),
-  targets: z13.optional(RulesyncTargetsSchema),
-  description: z13.optional(z13.string()),
-  globs: z13.optional(z13.array(z13.string())),
-  cursor: z13.optional(
+var RulesyncSubagentModelSchema = z13.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = z13.object({
+  targets: RulesyncTargetsSchema,
+  name: z13.string(),
+  description: z13.string(),
+  claudecode: z13.optional(
     z13.object({
-      alwaysApply: z13.optional(z13.boolean()),
-      description: z13.optional(z13.string()),
-      globs: z13.optional(z13.array(z13.string()))
+      model: RulesyncSubagentModelSchema
     })
   )
 });
-var RulesyncRule = class _RulesyncRule extends RulesyncFile {
+var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
   body;
   constructor({ frontmatter, body, ...rest }) {
     if (rest.validate !== false) {
-      const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+      const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw result.error;
       }
     }
     super({
-      ...rest,
-      fileContent: stringifyFrontmatter(body, frontmatter)
+      ...rest
     });
     this.frontmatter = frontmatter;
     this.body = body;
   }
   static getSettablePaths() {
     return {
-      recommended: {
-        relativeDirPath: ".rulesync/rules"
-      },
-      legacy: {
-        relativeDirPath: ".rulesync"
-      }
+      relativeDirPath: ".rulesync/subagents"
     };
   }
   getFrontmatter() {
     return this.frontmatter;
   }
+  getBody() {
+    return this.body;
+  }
   validate() {
     if (!this.frontmatter) {
       return { success: true, error: null };
     }
-    const result = RulesyncRuleFrontmatterSchema.safeParse(this.frontmatter);
+    const result = RulesyncSubagentFrontmatterSchema.safeParse(this.frontmatter);
     if (result.success) {
       return { success: true, error: null };
     } else {
       return { success: false, error: result.error };
     }
   }
-  static async fromFileLegacy({
-    relativeFilePath,
-    validate = true
+  static async fromFile({
+    relativeFilePath
   }) {
-    const filePath = join31(this.getSettablePaths().legacy.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(filePath);
+    const fileContent = await readFileContent(join31(RULESYNC_SUBAGENTS_DIR, relativeFilePath));
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+    const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
     }
-    const validatedFrontmatter = {
-      root: result.data.root ?? false,
-      targets: result.data.targets ?? ["*"],
-      description: result.data.description ?? "",
-      globs: result.data.globs ?? [],
-      cursor: result.data.cursor
-    };
-    const filename = basename12(filePath);
-    return new _RulesyncRule({
+    const filename = basename12(relativeFilePath);
+    return new _RulesyncSubagent({
       baseDir: ".",
-      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
       relativeFilePath: filename,
-      frontmatter: validatedFrontmatter,
+      frontmatter: result.data,
       body: content.trim(),
-      validate
+      fileContent
     });
   }
-  static async fromFile({
-    relativeFilePath,
-    validate = true
-  }) {
-    const filePath = join31(this.getSettablePaths().recommended.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(filePath);
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+};
+
+// src/subagents/claudecode-subagent.ts
+var ClaudecodeSubagentFrontmatterSchema = z14.object({
+  name: z14.string(),
+  description: z14.string(),
+  model: z14.optional(z14.enum(["opus", "sonnet", "haiku", "inherit"]))
+});
+var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw result.error;
+      }
     }
-    const validatedFrontmatter = {
-      root: result.data.root ?? false,
-      targets: result.data.targets ?? ["*"],
-      description: result.data.description ?? "",
-      globs: result.data.globs ?? [],
-      cursor: result.data.cursor
-    };
-    const filename = basename12(filePath);
-    return new _RulesyncRule({
-      baseDir: ".",
-      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
-      relativeFilePath: filename,
-      frontmatter: validatedFrontmatter,
-      body: content.trim(),
-      validate
+    super({
+      ...rest
     });
+    this.frontmatter = frontmatter;
+    this.body = body;
   }
-  getBody() {
-    return this.body;
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".claude/agents"
+    };
   }
-};
-
-// src/rules/tool-rule.ts
-var ToolRule = class extends ToolFile {
-  root;
-  constructor({ root = false, ...rest }) {
-    super(rest);
-    this.root = root;
+  getFrontmatter() {
+    return this.frontmatter;
   }
-  static async fromFile(_params) {
-    throw new Error("Please implement this method in the subclass.");
+  getBody() {
+    return this.body;
   }
-  static fromRulesyncRule(_params) {
-    throw new Error("Please implement this method in the subclass.");
+  toRulesyncSubagent() {
+    const rulesyncFrontmatter = {
+      targets: ["claudecode"],
+      name: this.frontmatter.name,
+      description: this.frontmatter.description,
+      ...this.frontmatter.model && {
+        claudecode: {
+          model: this.frontmatter.model
+        }
+      }
+    };
+    const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
+    return new RulesyncSubagent({
+      frontmatter: rulesyncFrontmatter,
+      body: this.body,
+      baseDir: this.baseDir,
+      relativeDirPath: ".rulesync/subagents",
+      relativeFilePath: this.getRelativeFilePath(),
+      fileContent,
+      validate: true
+    });
   }
-  static buildToolRuleParamsDefault({
+  static fromRulesyncSubagent({
     baseDir = ".",
-    rulesyncRule,
-    validate = true,
-    rootPath = { relativeDirPath: ".", relativeFilePath: "AGENTS.md" },
-    nonRootPath = { relativeDirPath: ".agents/memories" }
+    rulesyncSubagent,
+    validate = true
   }) {
-    const fileContent = rulesyncRule.getBody();
-    return {
+    const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+    const claudecodeFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description,
+      model: rulesyncFrontmatter.claudecode?.model
+    };
+    const body = rulesyncSubagent.getBody();
+    const fileContent = stringifyFrontmatter(body, claudecodeFrontmatter);
+    return new _ClaudecodeSubagent({
       baseDir,
-      relativeDirPath: rulesyncRule.getFrontmatter().root ? rootPath.relativeDirPath : nonRootPath.relativeDirPath,
-      relativeFilePath: rulesyncRule.getFrontmatter().root ? rootPath.relativeFilePath : rulesyncRule.getRelativeFilePath(),
+      frontmatter: claudecodeFrontmatter,
+      body,
+      relativeDirPath: ".claude/agents",
+      relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
       fileContent,
-      validate,
-      root: rulesyncRule.getFrontmatter().root ?? false
-    };
-  }
-  toRulesyncRuleDefault() {
-    return new RulesyncRule({
-      baseDir: this.getBaseDir(),
-      relativeDirPath: RULESYNC_RULES_DIR,
-      relativeFilePath: this.getRelativeFilePath(),
-      frontmatter: {
-        root: this.isRoot(),
-        targets: ["*"],
-        description: "",
-        globs: this.isRoot() ? ["**/*"] : []
-      },
-      body: this.getFileContent()
+      validate
     });
   }
-  isRoot() {
-    return this.root;
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = ClaudecodeSubagentFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return { success: false, error: result.error };
+    }
   }
-  static isTargetedByRulesyncRule(_rulesyncRule) {
-    throw new Error("Please implement this method in the subclass.");
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "claudecode"
+    });
   }
-  static isTargetedByRulesyncRuleDefault({
-    rulesyncRule,
-    toolTarget
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
   }) {
-    const targets = rulesyncRule.getFrontmatter().targets;
-    if (!targets) {
-      return true;
-    }
-    if (targets.includes("*")) {
-      return true;
+    const fileContent = await readFileContent(join32(baseDir, ".claude/agents", relativeFilePath));
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
     }
-    if (targets.includes(toolTarget)) {
+    return new _ClaudecodeSubagent({
+      baseDir,
+      relativeDirPath: ".claude/agents",
+      relativeFilePath,
+      frontmatter: result.data,
+      body: content.trim(),
+      fileContent,
+      validate
+    });
+  }
+};
+
+// src/subagents/subagents-processor.ts
+var subagentsProcessorToolTargets = [
+  "claudecode",
+  "copilot",
+  "cursor",
+  "codexcli",
+  "geminicli",
+  "roo"
+];
+var subagentsProcessorToolTargetsSimulated = [
+  "copilot",
+  "cursor",
+  "codexcli",
+  "geminicli",
+  "roo"
+];
+var SubagentsProcessorToolTargetSchema = z15.enum(subagentsProcessorToolTargets);
+var SubagentsProcessor = class extends FeatureProcessor {
+  toolTarget;
+  constructor({
+    baseDir = ".",
+    toolTarget
+  }) {
+    super({ baseDir });
+    this.toolTarget = SubagentsProcessorToolTargetSchema.parse(toolTarget);
+  }
+  async convertRulesyncFilesToToolFiles(rulesyncFiles) {
+    const rulesyncSubagents = rulesyncFiles.filter(
+      (file) => file instanceof RulesyncSubagent
+    );
+    const toolSubagents = rulesyncSubagents.map((rulesyncSubagent) => {
+      switch (this.toolTarget) {
+        case "claudecode":
+          if (!ClaudecodeSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return ClaudecodeSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "copilot":
+          if (!CopilotSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return CopilotSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "cursor":
+          if (!CursorSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return CursorSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "codexcli":
+          if (!CodexCliSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return CodexCliSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "geminicli":
+          if (!GeminiCliSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return GeminiCliSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "roo":
+          if (!RooSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return RooSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        default:
+          throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+      }
+    }).filter((subagent) => subagent !== null);
+    return toolSubagents;
+  }
+  async convertToolFilesToRulesyncFiles(toolFiles) {
+    const toolSubagents = toolFiles.filter(
+      (file) => file instanceof ToolSubagent
+    );
+    const rulesyncSubagents = [];
+    for (const toolSubagent of toolSubagents) {
+      if (toolSubagent instanceof SimulatedSubagent) {
+        logger.debug(
+          `Skipping simulated subagent conversion: ${toolSubagent.getRelativeFilePath()}`
+        );
+        continue;
+      }
+      rulesyncSubagents.push(toolSubagent.toRulesyncSubagent());
+    }
+    return rulesyncSubagents;
+  }
+  /**
+   * Implementation of abstract method from Processor
+   * Load and parse rulesync subagent files from .rulesync/subagents/ directory
+   */
+  async loadRulesyncFiles() {
+    const subagentsDir = join33(this.baseDir, RulesyncSubagent.getSettablePaths().relativeDirPath);
+    const dirExists = await directoryExists(subagentsDir);
+    if (!dirExists) {
+      logger.debug(`Rulesync subagents directory not found: ${subagentsDir}`);
+      return [];
+    }
+    const entries = await listDirectoryFiles(subagentsDir);
+    const mdFiles = entries.filter((file) => file.endsWith(".md"));
+    if (mdFiles.length === 0) {
+      logger.debug(`No markdown files found in rulesync subagents directory: ${subagentsDir}`);
+      return [];
+    }
+    logger.info(`Found ${mdFiles.length} subagent files in ${subagentsDir}`);
+    const rulesyncSubagents = [];
+    for (const mdFile of mdFiles) {
+      const filepath = join33(subagentsDir, mdFile);
+      try {
+        const rulesyncSubagent = await RulesyncSubagent.fromFile({
+          relativeFilePath: mdFile,
+          validate: true
+        });
+        rulesyncSubagents.push(rulesyncSubagent);
+        logger.debug(`Successfully loaded subagent: ${mdFile}`);
+      } catch (error) {
+        logger.warn(`Failed to load subagent file ${filepath}:`, error);
+        continue;
+      }
+    }
+    if (rulesyncSubagents.length === 0) {
+      logger.debug(`No valid subagents found in ${subagentsDir}`);
+      return [];
+    }
+    logger.info(`Successfully loaded ${rulesyncSubagents.length} rulesync subagents`);
+    return rulesyncSubagents;
+  }
+  /**
+   * Implementation of abstract method from Processor
+   * Load tool-specific subagent configurations and parse them into ToolSubagent instances
+   */
+  async loadToolFiles() {
+    switch (this.toolTarget) {
+      case "claudecode":
+        return await this.loadClaudecodeSubagents();
+      case "copilot":
+        return await this.loadCopilotSubagents();
+      case "cursor":
+        return await this.loadCursorSubagents();
+      case "codexcli":
+        return await this.loadCodexCliSubagents();
+      case "geminicli":
+        return await this.loadGeminiCliSubagents();
+      case "roo":
+        return await this.loadRooSubagents();
+      default:
+        throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+    }
+  }
+  /**
+   * Load Claude Code subagent configurations from .claude/agents/ directory
+   */
+  async loadClaudecodeSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: ClaudecodeSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => ClaudecodeSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load Copilot subagent configurations from .github/subagents/ directory
+   */
+  async loadCopilotSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: CopilotSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => CopilotSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load Cursor subagent configurations from .cursor/subagents/ directory
+   */
+  async loadCursorSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: CursorSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => CursorSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load CodexCli subagent configurations from .codex/subagents/ directory
+   */
+  async loadCodexCliSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: CodexCliSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => CodexCliSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load GeminiCli subagent configurations from .gemini/subagents/ directory
+   */
+  async loadGeminiCliSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: GeminiCliSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => GeminiCliSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load Roo subagent configurations from .roo/subagents/ directory
+   */
+  async loadRooSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: RooSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => RooSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  async loadToolSubagentsDefault({
+    relativeDirPath,
+    fromFile
+  }) {
+    const paths = await findFilesByGlobs(join33(this.baseDir, relativeDirPath, "*.md"));
+    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile(basename13(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
+    logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
+    return subagents;
+  }
+  /**
+   * Implementation of abstract method from FeatureProcessor
+   * Return the tool targets that this processor supports
+   */
+  static getToolTargets({
+    includeSimulated = false
+  } = {}) {
+    if (!includeSimulated) {
+      return subagentsProcessorToolTargets.filter(
+        (target) => !subagentsProcessorToolTargetsSimulated.includes(target)
+      );
+    }
+    return subagentsProcessorToolTargets;
+  }
+  static getToolTargetsSimulated() {
+    return subagentsProcessorToolTargetsSimulated;
+  }
+};
+
+// src/rules/agentsmd-rule.ts
+import { join as join35 } from "path";
+
+// src/rules/rulesync-rule.ts
+import { basename as basename14, join as join34 } from "path";
+import { z as z16 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z16.object({
+  root: z16.optional(z16.optional(z16.boolean())),
+  targets: z16.optional(RulesyncTargetsSchema),
+  description: z16.optional(z16.string()),
+  globs: z16.optional(z16.array(z16.string())),
+  cursor: z16.optional(
+    z16.object({
+      alwaysApply: z16.optional(z16.boolean()),
+      description: z16.optional(z16.string()),
+      globs: z16.optional(z16.array(z16.string()))
+    })
+  )
+});
+var RulesyncRule = class _RulesyncRule extends RulesyncFile {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw result.error;
+      }
+    }
+    super({
+      ...rest,
+      fileContent: stringifyFrontmatter(body, frontmatter)
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
+  static getSettablePaths() {
+    return {
+      recommended: {
+        relativeDirPath: ".rulesync/rules"
+      },
+      legacy: {
+        relativeDirPath: ".rulesync"
+      }
+    };
+  }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = RulesyncRuleFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return { success: false, error: result.error };
+    }
+  }
+  static async fromFileLegacy({
+    relativeFilePath,
+    validate = true
+  }) {
+    const filePath = join34(this.getSettablePaths().legacy.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+    }
+    const validatedFrontmatter = {
+      root: result.data.root ?? false,
+      targets: result.data.targets ?? ["*"],
+      description: result.data.description ?? "",
+      globs: result.data.globs ?? [],
+      cursor: result.data.cursor
+    };
+    const filename = basename14(filePath);
+    return new _RulesyncRule({
+      baseDir: ".",
+      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
+      relativeFilePath: filename,
+      frontmatter: validatedFrontmatter,
+      body: content.trim(),
+      validate
+    });
+  }
+  static async fromFile({
+    relativeFilePath,
+    validate = true
+  }) {
+    const filePath = join34(this.getSettablePaths().recommended.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+    }
+    const validatedFrontmatter = {
+      root: result.data.root ?? false,
+      targets: result.data.targets ?? ["*"],
+      description: result.data.description ?? "",
+      globs: result.data.globs ?? [],
+      cursor: result.data.cursor
+    };
+    const filename = basename14(filePath);
+    return new _RulesyncRule({
+      baseDir: ".",
+      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
+      relativeFilePath: filename,
+      frontmatter: validatedFrontmatter,
+      body: content.trim(),
+      validate
+    });
+  }
+  getBody() {
+    return this.body;
+  }
+};
+
+// src/rules/tool-rule.ts
+var ToolRule = class extends ToolFile {
+  root;
+  constructor({ root = false, ...rest }) {
+    super(rest);
+    this.root = root;
+  }
+  static async fromFile(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static fromRulesyncRule(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static buildToolRuleParamsDefault({
+    baseDir = ".",
+    rulesyncRule,
+    validate = true,
+    rootPath = { relativeDirPath: ".", relativeFilePath: "AGENTS.md" },
+    nonRootPath = { relativeDirPath: ".agents/memories" }
+  }) {
+    const fileContent = rulesyncRule.getBody();
+    return {
+      baseDir,
+      relativeDirPath: rulesyncRule.getFrontmatter().root ? rootPath.relativeDirPath : nonRootPath.relativeDirPath,
+      relativeFilePath: rulesyncRule.getFrontmatter().root ? rootPath.relativeFilePath : rulesyncRule.getRelativeFilePath(),
+      fileContent,
+      validate,
+      root: rulesyncRule.getFrontmatter().root ?? false
+    };
+  }
+  toRulesyncRuleDefault() {
+    return new RulesyncRule({
+      baseDir: this.getBaseDir(),
+      relativeDirPath: RULESYNC_RULES_DIR,
+      relativeFilePath: this.getRelativeFilePath(),
+      frontmatter: {
+        root: this.isRoot(),
+        targets: ["*"],
+        description: "",
+        globs: this.isRoot() ? ["**/*"] : []
+      },
+      body: this.getFileContent()
+    });
+  }
+  isRoot() {
+    return this.root;
+  }
+  static isTargetedByRulesyncRule(_rulesyncRule) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static isTargetedByRulesyncRuleDefault({
+    rulesyncRule,
+    toolTarget
+  }) {
+    const targets = rulesyncRule.getFrontmatter().targets;
+    if (!targets) {
+      return true;
+    }
+    if (targets.includes("*")) {
+      return true;
+    }
+    if (targets.includes(toolTarget)) {
       return true;
     }
     return false;
@@ -3194,8 +3694,8 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join32(".agents/memories", relativeFilePath);
-    const fileContent = await readFileContent(join32(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : join35(".agents/memories", relativeFilePath);
+    const fileContent = await readFileContent(join35(baseDir, relativePath));
     return new _AgentsMdRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3235,7 +3735,7 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 };
 
 // src/rules/amazonqcli-rule.ts
-import { join as join33 } from "path";
+import { join as join36 } from "path";
 var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3250,7 +3750,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join33(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join36(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _AmazonQCliRule({
       baseDir,
@@ -3290,7 +3790,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 };
 
 // src/rules/augmentcode-legacy-rule.ts
-import { join as join34 } from "path";
+import { join as join37 } from "path";
 var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   toRulesyncRule() {
     const rulesyncFrontmatter = {
@@ -3350,8 +3850,8 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   }) {
     const settablePaths = this.getSettablePaths();
     const isRoot = relativeFilePath === settablePaths.root.relativeFilePath;
-    const relativePath = isRoot ? settablePaths.root.relativeFilePath : join34(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join34(baseDir, relativePath));
+    const relativePath = isRoot ? settablePaths.root.relativeFilePath : join37(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join37(baseDir, relativePath));
     return new _AugmentcodeLegacyRule({
       baseDir,
       relativeDirPath: isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath,
@@ -3364,7 +3864,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
 };
 
 // src/rules/augmentcode-rule.ts
-import { join as join35 } from "path";
+import { join as join38 } from "path";
 var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   toRulesyncRule() {
     return this.toRulesyncRuleDefault();
@@ -3396,7 +3896,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join35(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join38(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     const { body: content } = parseFrontmatter(fileContent);
     return new _AugmentcodeRule({
@@ -3419,7 +3919,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
 };
 
 // src/rules/claudecode-rule.ts
-import { join as join36 } from "path";
+import { join as join39 } from "path";
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3438,8 +3938,8 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join36(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join36(baseDir, relativePath));
+    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join39(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join39(baseDir, relativePath));
     return new _ClaudecodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3479,10 +3979,10 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 };
 
 // src/rules/cline-rule.ts
-import { join as join37 } from "path";
-import { z as z14 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z14.object({
-  description: z14.string()
+import { join as join40 } from "path";
+import { z as z17 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z17.object({
+  description: z17.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -3524,7 +4024,7 @@ var ClineRule = class _ClineRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join37(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join40(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _ClineRule({
       baseDir,
@@ -3537,7 +4037,7 @@ var ClineRule = class _ClineRule extends ToolRule {
 };
 
 // src/rules/codexcli-rule.ts
-import { join as join38 } from "path";
+import { join as join41 } from "path";
 var CodexcliRule = class _CodexcliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3556,8 +4056,8 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join38(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join38(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : join41(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join41(baseDir, relativePath));
     return new _CodexcliRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3597,11 +4097,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 };
 
 // src/rules/copilot-rule.ts
-import { join as join39 } from "path";
-import { z as z15 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z15.object({
-  description: z15.optional(z15.string()),
-  applyTo: z15.optional(z15.string())
+import { join as join42 } from "path";
+import { z as z18 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z18.object({
+  description: z18.optional(z18.string()),
+  applyTo: z18.optional(z18.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -3689,11 +4189,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "copilot-instructions.md";
-    const relativePath = isRoot ? join39(
+    const relativePath = isRoot ? join42(
       this.getSettablePaths().root.relativeDirPath,
       this.getSettablePaths().root.relativeFilePath
-    ) : join39(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join39(baseDir, relativePath));
+    ) : join42(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join42(baseDir, relativePath));
     if (isRoot) {
       return new _CopilotRule({
         baseDir,
@@ -3712,7 +4212,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(
-        `Invalid frontmatter in ${join39(baseDir, relativeFilePath)}: ${result.error.message}`
+        `Invalid frontmatter in ${join42(baseDir, relativeFilePath)}: ${result.error.message}`
       );
     }
     return new _CopilotRule({
@@ -3751,12 +4251,12 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 };
 
 // src/rules/cursor-rule.ts
-import { basename as basename13, join as join40 } from "path";
-import { z as z16 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z16.object({
-  description: z16.optional(z16.string()),
-  globs: z16.optional(z16.string()),
-  alwaysApply: z16.optional(z16.boolean())
+import { basename as basename15, join as join43 } from "path";
+import { z as z19 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z19.object({
+  description: z19.optional(z19.string()),
+  globs: z19.optional(z19.string()),
+  alwaysApply: z19.optional(z19.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -3881,19 +4381,19 @@ var CursorRule = class _CursorRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join40(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join43(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 ${join40(baseDir, relativeFilePath)}: ${result.error.message}`
+        `Invalid frontmatter in ${join43(baseDir, relativeFilePath)}: ${result.error.message}`
       );
     }
     return new _CursorRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: basename13(relativeFilePath),
+      relativeFilePath: basename15(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -3925,7 +4425,7 @@ var CursorRule = class _CursorRule extends ToolRule {
 };
 
 // src/rules/geminicli-rule.ts
-import { join as join41 } from "path";
+import { join as join44 } from "path";
 var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3944,8 +4444,8 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "GEMINI.md";
-    const relativePath = isRoot ? "GEMINI.md" : join41(".gemini/memories", relativeFilePath);
-    const fileContent = await readFileContent(join41(baseDir, relativePath));
+    const relativePath = isRoot ? "GEMINI.md" : join44(".gemini/memories", relativeFilePath);
+    const fileContent = await readFileContent(join44(baseDir, relativePath));
     return new _GeminiCliRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3985,7 +4485,7 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
 };
 
 // src/rules/junie-rule.ts
-import { join as join42 } from "path";
+import { join as join45 } from "path";
 var JunieRule = class _JunieRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4004,8 +4504,8 @@ var JunieRule = class _JunieRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "guidelines.md";
-    const relativePath = isRoot ? "guidelines.md" : join42(".junie/memories", relativeFilePath);
-    const fileContent = await readFileContent(join42(baseDir, relativePath));
+    const relativePath = isRoot ? "guidelines.md" : join45(".junie/memories", relativeFilePath);
+    const fileContent = await readFileContent(join45(baseDir, relativePath));
     return new _JunieRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4045,7 +4545,7 @@ var JunieRule = class _JunieRule extends ToolRule {
 };
 
 // src/rules/kiro-rule.ts
-import { join as join43 } from "path";
+import { join as join46 } from "path";
 var KiroRule = class _KiroRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4060,7 +4560,7 @@ var KiroRule = class _KiroRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join43(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join46(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _KiroRule({
       baseDir,
@@ -4100,7 +4600,7 @@ var KiroRule = class _KiroRule extends ToolRule {
 };
 
 // src/rules/opencode-rule.ts
-import { join as join44 } from "path";
+import { join as join47 } from "path";
 var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4119,8 +4619,8 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join44(".opencode/memories", relativeFilePath);
-    const fileContent = await readFileContent(join44(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : join47(".opencode/memories", relativeFilePath);
+    const fileContent = await readFileContent(join47(baseDir, relativePath));
     return new _OpenCodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4160,7 +4660,7 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
 };
 
 // src/rules/qwencode-rule.ts
-import { join as join45 } from "path";
+import { join as join48 } from "path";
 var QwencodeRule = class _QwencodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4179,8 +4679,8 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "QWEN.md";
-    const relativePath = isRoot ? "QWEN.md" : join45(".qwen/memories", relativeFilePath);
-    const fileContent = await readFileContent(join45(baseDir, relativePath));
+    const relativePath = isRoot ? "QWEN.md" : join48(".qwen/memories", relativeFilePath);
+    const fileContent = await readFileContent(join48(baseDir, relativePath));
     return new _QwencodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4217,7 +4717,7 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
 };
 
 // src/rules/roo-rule.ts
-import { join as join46 } from "path";
+import { join as join49 } from "path";
 var RooRule = class _RooRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4232,7 +4732,7 @@ var RooRule = class _RooRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join46(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join49(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _RooRule({
       baseDir,
@@ -4287,7 +4787,7 @@ var RooRule = class _RooRule extends ToolRule {
 };
 
 // src/rules/warp-rule.ts
-import { join as join47 } from "path";
+import { join as join50 } from "path";
 var WarpRule = class _WarpRule extends ToolRule {
   constructor({ fileContent, root, ...rest }) {
     super({
@@ -4313,8 +4813,8 @@ var WarpRule = class _WarpRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join47(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join47(baseDir, relativePath));
+    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join50(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join50(baseDir, relativePath));
     return new _WarpRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : ".warp",
@@ -4354,7 +4854,7 @@ var WarpRule = class _WarpRule extends ToolRule {
 };
 
 // src/rules/windsurf-rule.ts
-import { join as join48 } from "path";
+import { join as join51 } from "path";
 var WindsurfRule = class _WindsurfRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4369,7 +4869,7 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join48(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join51(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _WindsurfRule({
       baseDir,
@@ -4427,7 +4927,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z17.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z20.enum(rulesProcessorToolTargets);
 var RulesProcessor = class extends FeatureProcessor {
   toolTarget;
   simulateCommands;
@@ -4606,7 +5106,8 @@ var RulesProcessor = class extends FeatureProcessor {
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
     }).filter((rule) => rule !== null);
-    if (this.toolTarget === "cursor" && (this.simulateCommands || this.simulateSubagents)) {
+    const isSimulated = this.simulateCommands || this.simulateSubagents;
+    if (isSimulated && this.toolTarget === "cursor") {
       toolRules.push(
         new CursorRule({
           baseDir: this.baseDir,
@@ -4625,6 +5126,22 @@ var RulesProcessor = class extends FeatureProcessor {
         })
       );
     }
+    if (isSimulated && this.toolTarget === "roo") {
+      toolRules.push(
+        new RooRule({
+          baseDir: this.baseDir,
+          relativeDirPath: RooRule.getSettablePaths().nonRoot.relativeDirPath,
+          relativeFilePath: "additional-conventions.md",
+          fileContent: this.generateAdditionalConventionsSection({
+            commands: { relativeDirPath: RooCommand.getSettablePaths().relativeDirPath },
+            subagents: {
+              relativeDirPath: RooSubagent.getSettablePaths().relativeDirPath
+            }
+          }),
+          validate: true
+        })
+      );
+    }
     const rootRuleIndex = toolRules.findIndex((rule) => rule.isRoot());
     if (rootRuleIndex === -1) {
       return toolRules;
@@ -4678,7 +5195,12 @@ var RulesProcessor = class extends FeatureProcessor {
       case "geminicli": {
         const rootRule = toolRules[rootRuleIndex];
         rootRule?.setFileContent(
-          this.generateXmlReferencesSection(toolRules) + rootRule.getFileContent()
+          this.generateXmlReferencesSection(toolRules) + this.generateAdditionalConventionsSection({
+            commands: { relativeDirPath: GeminiCliCommand.getSettablePaths().relativeDirPath },
+            subagents: {
+              relativeDirPath: GeminiCliSubagent.getSettablePaths().relativeDirPath
+            }
+          }) + rootRule.getFileContent()
         );
         return toolRules;
       }
@@ -4726,17 +5248,17 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    const files = await findFilesByGlobs(join49(RULESYNC_RULES_DIR, "*.md"));
+    const files = await findFilesByGlobs(join52(RULESYNC_RULES_DIR, "*.md"));
     logger.debug(`Found ${files.length} rulesync files`);
     return Promise.all(
-      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename14(file) }))
+      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename16(file) }))
     );
   }
   async loadRulesyncFilesLegacy() {
-    const legacyFiles = await findFilesByGlobs(join49(RULESYNC_RULES_DIR_LEGACY, "*.md"));
+    const legacyFiles = await findFilesByGlobs(join52(RULESYNC_RULES_DIR_LEGACY, "*.md"));
     logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
     return Promise.all(
-      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename14(file) }))
+      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename16(file) }))
     );
   }
   /**
@@ -4797,803 +5319,405 @@ var RulesProcessor = class extends FeatureProcessor {
         return [];
       }
       const rootFilePaths = await findFilesByGlobs(
-        join49(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
+        join52(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
       );
       return await Promise.all(
         rootFilePaths.map(
           (filePath) => root.fromFile({
             baseDir: this.baseDir,
-            relativeFilePath: basename14(filePath)
-          })
-        )
-      );
-    })();
-    logger.debug(`Found ${rootToolRules.length} root tool rule files`);
-    const nonRootToolRules = await (async () => {
-      if (!nonRoot) {
-        return [];
-      }
-      const nonRootFilePaths = await findFilesByGlobs(
-        join49(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
-      );
-      return await Promise.all(
-        nonRootFilePaths.map(
-          (filePath) => nonRoot.fromFile({
-            baseDir: this.baseDir,
-            relativeFilePath: basename14(filePath)
+            relativeFilePath: basename16(filePath)
           })
         )
       );
-    })();
-    logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
-    return [...rootToolRules, ...nonRootToolRules];
-  }
-  /**
-   * Load AGENTS.md rule configuration
-   */
-  async loadAgentsmdRules() {
-    const settablePaths = AgentsMdRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => AgentsMdRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => AgentsMdRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  async loadWarpRules() {
-    const settablePaths = WarpRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => WarpRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => WarpRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Amazon Q Developer CLI rule configurations from .amazonq/rules/ directory
-   */
-  async loadAmazonqcliRules() {
-    const settablePaths = AmazonQCliRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => AmazonQCliRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load AugmentCode rule configurations from .augment/rules/ directory
-   */
-  async loadAugmentcodeRules() {
-    const settablePaths = AugmentcodeRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => AugmentcodeRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load AugmentCode legacy rule configuration from .augment-guidelines file and .augment/rules/ directory
-   */
-  async loadAugmentcodeLegacyRules() {
-    const settablePaths = AugmentcodeLegacyRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => AugmentcodeLegacyRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => AugmentcodeLegacyRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Claude Code rule configuration from CLAUDE.md file
-   */
-  async loadClaudecodeRules() {
-    const settablePaths = ClaudecodeRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => ClaudecodeRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => ClaudecodeRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Cline rule configurations from .clinerules/ directory
-   */
-  async loadClineRules() {
-    const settablePaths = ClineRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => ClineRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load OpenAI Codex CLI rule configuration from AGENTS.md and .codex/memories/*.md files
-   */
-  async loadCodexcliRules() {
-    const settablePaths = CodexcliRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => CodexcliRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => CodexcliRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load GitHub Copilot rule configuration from .github/copilot-instructions.md file
-   */
-  async loadCopilotRules() {
-    const settablePaths = CopilotRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => CopilotRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => CopilotRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Cursor rule configurations from .cursor/rules/ directory
-   */
-  async loadCursorRules() {
-    const settablePaths = CursorRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => CursorRule.fromFile(params),
-        extension: "mdc"
-      }
-    });
-  }
-  /**
-   * Load Gemini CLI rule configuration from GEMINI.md file
-   */
-  async loadGeminicliRules() {
-    const settablePaths = GeminiCliRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => GeminiCliRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => GeminiCliRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load JetBrains Junie rule configuration from .junie/guidelines.md file
-   */
-  async loadJunieRules() {
-    const settablePaths = JunieRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      root: {
-        relativeDirPath: settablePaths.root.relativeDirPath,
-        relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => JunieRule.fromFile(params)
-      },
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => JunieRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Kiro rule configurations from .kiro/steering/ directory
-   */
-  async loadKiroRules() {
-    const settablePaths = KiroRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => KiroRule.fromFile(params),
-        extension: "md"
+    })();
+    logger.debug(`Found ${rootToolRules.length} root tool rule files`);
+    const nonRootToolRules = await (async () => {
+      if (!nonRoot) {
+        return [];
       }
-    });
+      const nonRootFilePaths = await findFilesByGlobs(
+        join52(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
+      );
+      return await Promise.all(
+        nonRootFilePaths.map(
+          (filePath) => nonRoot.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: basename16(filePath)
+          })
+        )
+      );
+    })();
+    logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
+    return [...rootToolRules, ...nonRootToolRules];
   }
   /**
-   * Load OpenCode rule configuration from AGENTS.md file and .opencode/memories/*.md files
+   * Load AGENTS.md rule configuration
    */
-  async loadOpencodeRules() {
-    const settablePaths = OpenCodeRule.getSettablePaths();
+  async loadAgentsmdRules() {
+    const settablePaths = AgentsMdRule.getSettablePaths();
     return await this.loadToolRulesDefault({
       root: {
         relativeDirPath: settablePaths.root.relativeDirPath,
         relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => OpenCodeRule.fromFile(params)
+        fromFile: (params) => AgentsMdRule.fromFile(params)
       },
       nonRoot: {
         relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => OpenCodeRule.fromFile(params),
+        fromFile: (params) => AgentsMdRule.fromFile(params),
         extension: "md"
       }
     });
   }
-  /**
-   * Load Qwen Code rule configuration from QWEN.md file and .qwen/memories/*.md files
-   */
-  async loadQwencodeRules() {
-    const settablePaths = QwencodeRule.getSettablePaths();
+  async loadWarpRules() {
+    const settablePaths = WarpRule.getSettablePaths();
     return await this.loadToolRulesDefault({
       root: {
         relativeDirPath: settablePaths.root.relativeDirPath,
         relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => QwencodeRule.fromFile(params)
+        fromFile: (params) => WarpRule.fromFile(params)
       },
       nonRoot: {
         relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => QwencodeRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Roo Code rule configurations from .roo/rules/ directory
-   */
-  async loadRooRules() {
-    const settablePaths = RooRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => RooRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Windsurf rule configurations from .windsurf/rules/ directory
-   */
-  async loadWindsurfRules() {
-    const settablePaths = WindsurfRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => WindsurfRule.fromFile(params),
+        fromFile: (params) => WarpRule.fromFile(params),
         extension: "md"
       }
     });
   }
-  /**
-   * Implementation of abstract method from FeatureProcessor
-   * Return the tool targets that this processor supports
-   */
-  static getToolTargets() {
-    return rulesProcessorToolTargets;
-  }
-  generateXmlReferencesSection(toolRules) {
-    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
-    if (toolRulesWithoutRoot.length === 0) {
-      return "";
-    }
-    const lines = [];
-    lines.push(
-      "Please also reference the following documents as needed. In this case, `@` stands for the project root directory."
-    );
-    lines.push("");
-    const documentsData = {
-      Documents: {
-        Document: toolRulesWithoutRoot.map((rule) => {
-          const rulesyncRule = rule.toRulesyncRule();
-          const frontmatter = rulesyncRule.getFrontmatter();
-          const relativePath = `@${rule.getRelativePathFromCwd()}`;
-          const document = {
-            Path: relativePath
-          };
-          if (frontmatter.description) {
-            document.Description = frontmatter.description;
-          }
-          if (frontmatter.globs && frontmatter.globs.length > 0) {
-            document.FilePatterns = frontmatter.globs.join(", ");
-          }
-          return document;
-        })
-      }
-    };
-    const builder = new XMLBuilder({
-      format: true,
-      ignoreAttributes: false,
-      suppressEmptyNode: false
-    });
-    const xmlContent = builder.build(documentsData);
-    lines.push(xmlContent);
-    return lines.join("\n") + "\n";
-  }
-  generateReferencesSection(toolRules) {
-    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
-    if (toolRulesWithoutRoot.length === 0) {
-      return "";
-    }
-    const lines = [];
-    lines.push("Please also reference the following documents as needed:");
-    lines.push("");
-    for (const rule of toolRulesWithoutRoot) {
-      const rulesyncRule = rule.toRulesyncRule();
-      const frontmatter = rulesyncRule.getFrontmatter();
-      const escapedDescription = frontmatter.description?.replace(/"/g, '\\"');
-      const globsText = frontmatter.globs?.join(",");
-      lines.push(
-        `@${rule.getRelativePathFromCwd()} description: "${escapedDescription}" globs: "${globsText}"`
-      );
-    }
-    return lines.join("\n") + "\n";
-  }
-  generateAdditionalConventionsSection({
-    commands,
-    subagents
-  }) {
-    return `# Additional Conventions Beyond the Built-in Functions
-
-As this project's AI coding tool, you must follow the additional conventions below, in addition to the built-in functions.
-
-${this.simulateCommands ? `## Simulated Custom Slash Commands
-
-Custom slash commands allow you to define frequently-used prompts as Markdown files that you can execute.
-
-### Syntax
-
-Users can use following syntax to invoke a custom command.
-
-\`\`\`txt
-s/<command> [arguments]
-\`\`\`
-
-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, \`${join49(commands.relativeDirPath, "{command}.md")}\`, then execute the contents of that file as the block of operations.` : ""}
-
-${this.simulateSubagents ? `## 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 simulated custom slash commands simply. Simulated subagents can be called by simulated custom slash commands.
-
-When users call a simulated subagent, it will look for the corresponding markdown file, \`${join49(subagents.relativeDirPath, "{subagent}.md")}\`, and execute its contents as the block of operations.` : ""}`.trim();
-  }
-};
-
-// src/subagents/subagents-processor.ts
-import { basename as basename16, join as join52 } from "path";
-import { z as z20 } from "zod/mini";
-
-// src/subagents/claudecode-subagent.ts
-import { join as join51 } from "path";
-import { z as z19 } from "zod/mini";
-
-// src/subagents/rulesync-subagent.ts
-import { basename as basename15, join as join50 } from "path";
-import { z as z18 } from "zod/mini";
-var RulesyncSubagentModelSchema = z18.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = z18.object({
-  targets: RulesyncTargetsSchema,
-  name: z18.string(),
-  description: z18.string(),
-  claudecode: z18.optional(
-    z18.object({
-      model: RulesyncSubagentModelSchema
-    })
-  )
-});
-var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
-  frontmatter;
-  body;
-  constructor({ frontmatter, body, ...rest }) {
-    if (rest.validate !== false) {
-      const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
-      if (!result.success) {
-        throw result.error;
-      }
-    }
-    super({
-      ...rest
-    });
-    this.frontmatter = frontmatter;
-    this.body = body;
-  }
-  static getSettablePaths() {
-    return {
-      relativeDirPath: ".rulesync/subagents"
-    };
-  }
-  getFrontmatter() {
-    return this.frontmatter;
-  }
-  getBody() {
-    return this.body;
-  }
-  validate() {
-    if (!this.frontmatter) {
-      return { success: true, error: null };
-    }
-    const result = RulesyncSubagentFrontmatterSchema.safeParse(this.frontmatter);
-    if (result.success) {
-      return { success: true, error: null };
-    } else {
-      return { success: false, error: result.error };
-    }
-  }
-  static async fromFile({
-    relativeFilePath
-  }) {
-    const fileContent = await readFileContent(join50(RULESYNC_SUBAGENTS_DIR, relativeFilePath));
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
-    }
-    const filename = basename15(relativeFilePath);
-    return new _RulesyncSubagent({
-      baseDir: ".",
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: filename,
-      frontmatter: result.data,
-      body: content.trim(),
-      fileContent
-    });
-  }
-};
-
-// src/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z19.object({
-  name: z19.string(),
-  description: z19.string(),
-  model: z19.optional(z19.enum(["opus", "sonnet", "haiku", "inherit"]))
-});
-var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
-  frontmatter;
-  body;
-  constructor({ frontmatter, body, ...rest }) {
-    if (rest.validate !== false) {
-      const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
-      if (!result.success) {
-        throw result.error;
-      }
-    }
-    super({
-      ...rest
-    });
-    this.frontmatter = frontmatter;
-    this.body = body;
-  }
-  static getSettablePaths() {
-    return {
-      relativeDirPath: ".claude/agents"
-    };
-  }
-  getFrontmatter() {
-    return this.frontmatter;
-  }
-  getBody() {
-    return this.body;
-  }
-  toRulesyncSubagent() {
-    const rulesyncFrontmatter = {
-      targets: ["claudecode"],
-      name: this.frontmatter.name,
-      description: this.frontmatter.description,
-      ...this.frontmatter.model && {
-        claudecode: {
-          model: this.frontmatter.model
-        }
+  /**
+   * Load Amazon Q Developer CLI rule configurations from .amazonq/rules/ directory
+   */
+  async loadAmazonqcliRules() {
+    const settablePaths = AmazonQCliRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => AmazonQCliRule.fromFile(params),
+        extension: "md"
       }
-    };
-    const fileContent = stringifyFrontmatter(this.body, rulesyncFrontmatter);
-    return new RulesyncSubagent({
-      frontmatter: rulesyncFrontmatter,
-      body: this.body,
-      baseDir: this.baseDir,
-      relativeDirPath: ".rulesync/subagents",
-      relativeFilePath: this.getRelativeFilePath(),
-      fileContent,
-      validate: true
     });
   }
-  static fromRulesyncSubagent({
-    baseDir = ".",
-    rulesyncSubagent,
-    validate = true
-  }) {
-    const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
-    const claudecodeFrontmatter = {
-      name: rulesyncFrontmatter.name,
-      description: rulesyncFrontmatter.description,
-      model: rulesyncFrontmatter.claudecode?.model
-    };
-    const body = rulesyncSubagent.getBody();
-    const fileContent = stringifyFrontmatter(body, claudecodeFrontmatter);
-    return new _ClaudecodeSubagent({
-      baseDir,
-      frontmatter: claudecodeFrontmatter,
-      body,
-      relativeDirPath: ".claude/agents",
-      relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
-      fileContent,
-      validate
+  /**
+   * Load AugmentCode rule configurations from .augment/rules/ directory
+   */
+  async loadAugmentcodeRules() {
+    const settablePaths = AugmentcodeRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => AugmentcodeRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
-  validate() {
-    if (!this.frontmatter) {
-      return { success: true, error: null };
-    }
-    const result = ClaudecodeSubagentFrontmatterSchema.safeParse(this.frontmatter);
-    if (result.success) {
-      return { success: true, error: null };
-    } else {
-      return { success: false, error: result.error };
-    }
+  /**
+   * Load AugmentCode legacy rule configuration from .augment-guidelines file and .augment/rules/ directory
+   */
+  async loadAugmentcodeLegacyRules() {
+    const settablePaths = AugmentcodeLegacyRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => AugmentcodeLegacyRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => AugmentcodeLegacyRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
-  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
-    return this.isTargetedByRulesyncSubagentDefault({
-      rulesyncSubagent,
-      toolTarget: "claudecode"
+  /**
+   * Load Claude Code rule configuration from CLAUDE.md file
+   */
+  async loadClaudecodeRules() {
+    const settablePaths = ClaudecodeRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => ClaudecodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => ClaudecodeRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
-  static async fromFile({
-    baseDir = ".",
-    relativeFilePath,
-    validate = true
-  }) {
-    const fileContent = await readFileContent(join51(baseDir, ".claude/agents", relativeFilePath));
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
-    }
-    return new _ClaudecodeSubagent({
-      baseDir,
-      relativeDirPath: ".claude/agents",
-      relativeFilePath,
-      frontmatter: result.data,
-      body: content.trim(),
-      fileContent,
-      validate
+  /**
+   * Load Cline rule configurations from .clinerules/ directory
+   */
+  async loadClineRules() {
+    const settablePaths = ClineRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => ClineRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
-};
-
-// src/subagents/subagents-processor.ts
-var subagentsProcessorToolTargets = [
-  "claudecode",
-  "copilot",
-  "cursor",
-  "codexcli"
-];
-var subagentsProcessorToolTargetsSimulated = [
-  "copilot",
-  "cursor",
-  "codexcli"
-];
-var SubagentsProcessorToolTargetSchema = z20.enum(subagentsProcessorToolTargets);
-var SubagentsProcessor = class extends FeatureProcessor {
-  toolTarget;
-  constructor({
-    baseDir = ".",
-    toolTarget
-  }) {
-    super({ baseDir });
-    this.toolTarget = SubagentsProcessorToolTargetSchema.parse(toolTarget);
+  /**
+   * Load OpenAI Codex CLI rule configuration from AGENTS.md and .codex/memories/*.md files
+   */
+  async loadCodexcliRules() {
+    const settablePaths = CodexcliRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => CodexcliRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => CodexcliRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
-  async convertRulesyncFilesToToolFiles(rulesyncFiles) {
-    const rulesyncSubagents = rulesyncFiles.filter(
-      (file) => file instanceof RulesyncSubagent
-    );
-    const toolSubagents = rulesyncSubagents.map((rulesyncSubagent) => {
-      switch (this.toolTarget) {
-        case "claudecode":
-          if (!ClaudecodeSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
-            return null;
-          }
-          return ClaudecodeSubagent.fromRulesyncSubagent({
-            baseDir: this.baseDir,
-            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
-            rulesyncSubagent
-          });
-        case "copilot":
-          if (!CopilotSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
-            return null;
-          }
-          return CopilotSubagent.fromRulesyncSubagent({
-            baseDir: this.baseDir,
-            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
-            rulesyncSubagent
-          });
-        case "cursor":
-          if (!CursorSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
-            return null;
-          }
-          return CursorSubagent.fromRulesyncSubagent({
-            baseDir: this.baseDir,
-            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
-            rulesyncSubagent
-          });
-        case "codexcli":
-          if (!CodexCliSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
-            return null;
-          }
-          return CodexCliSubagent.fromRulesyncSubagent({
-            baseDir: this.baseDir,
-            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
-            rulesyncSubagent
-          });
-        default:
-          throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+  /**
+   * Load GitHub Copilot rule configuration from .github/copilot-instructions.md file
+   */
+  async loadCopilotRules() {
+    const settablePaths = CopilotRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => CopilotRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => CopilotRule.fromFile(params),
+        extension: "md"
       }
-    }).filter((subagent) => subagent !== null);
-    return toolSubagents;
+    });
   }
-  async convertToolFilesToRulesyncFiles(toolFiles) {
-    const toolSubagents = toolFiles.filter(
-      (file) => file instanceof ToolSubagent
-    );
-    const rulesyncSubagents = [];
-    for (const toolSubagent of toolSubagents) {
-      if (toolSubagent instanceof SimulatedSubagent) {
-        logger.debug(
-          `Skipping simulated subagent conversion: ${toolSubagent.getRelativeFilePath()}`
-        );
-        continue;
+  /**
+   * Load Cursor rule configurations from .cursor/rules/ directory
+   */
+  async loadCursorRules() {
+    const settablePaths = CursorRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => CursorRule.fromFile(params),
+        extension: "mdc"
       }
-      rulesyncSubagents.push(toolSubagent.toRulesyncSubagent());
-    }
-    return rulesyncSubagents;
+    });
   }
   /**
-   * Implementation of abstract method from Processor
-   * Load and parse rulesync subagent files from .rulesync/subagents/ directory
+   * Load Gemini CLI rule configuration from GEMINI.md file
    */
-  async loadRulesyncFiles() {
-    const subagentsDir = join52(this.baseDir, RulesyncSubagent.getSettablePaths().relativeDirPath);
-    const dirExists = await directoryExists(subagentsDir);
-    if (!dirExists) {
-      logger.debug(`Rulesync subagents directory not found: ${subagentsDir}`);
-      return [];
-    }
-    const entries = await listDirectoryFiles(subagentsDir);
-    const mdFiles = entries.filter((file) => file.endsWith(".md"));
-    if (mdFiles.length === 0) {
-      logger.debug(`No markdown files found in rulesync subagents directory: ${subagentsDir}`);
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} subagent files in ${subagentsDir}`);
-    const rulesyncSubagents = [];
-    for (const mdFile of mdFiles) {
-      const filepath = join52(subagentsDir, mdFile);
-      try {
-        const rulesyncSubagent = await RulesyncSubagent.fromFile({
-          relativeFilePath: mdFile,
-          validate: true
-        });
-        rulesyncSubagents.push(rulesyncSubagent);
-        logger.debug(`Successfully loaded subagent: ${mdFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load subagent file ${filepath}:`, error);
-        continue;
+  async loadGeminicliRules() {
+    const settablePaths = GeminiCliRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => GeminiCliRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => GeminiCliRule.fromFile(params),
+        extension: "md"
       }
-    }
-    if (rulesyncSubagents.length === 0) {
-      logger.debug(`No valid subagents found in ${subagentsDir}`);
-      return [];
-    }
-    logger.info(`Successfully loaded ${rulesyncSubagents.length} rulesync subagents`);
-    return rulesyncSubagents;
+    });
   }
   /**
-   * Implementation of abstract method from Processor
-   * Load tool-specific subagent configurations and parse them into ToolSubagent instances
+   * Load JetBrains Junie rule configuration from .junie/guidelines.md file
    */
-  async loadToolFiles() {
-    switch (this.toolTarget) {
-      case "claudecode":
-        return await this.loadClaudecodeSubagents();
-      case "copilot":
-        return await this.loadCopilotSubagents();
-      case "cursor":
-        return await this.loadCursorSubagents();
-      case "codexcli":
-        return await this.loadCodexCliSubagents();
-      default:
-        throw new Error(`Unsupported tool target: ${this.toolTarget}`);
-    }
+  async loadJunieRules() {
+    const settablePaths = JunieRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => JunieRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => JunieRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
-   * Load Claude Code subagent configurations from .claude/agents/ directory
+   * Load Kiro rule configurations from .kiro/steering/ directory
    */
-  async loadClaudecodeSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: ClaudecodeSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => ClaudecodeSubagent.fromFile({ relativeFilePath })
+  async loadKiroRules() {
+    const settablePaths = KiroRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => KiroRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
   /**
-   * Load Copilot subagent configurations from .copilot/subagents/ directory
+   * Load OpenCode rule configuration from AGENTS.md file and .opencode/memories/*.md files
    */
-  async loadCopilotSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: CopilotSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => CopilotSubagent.fromFile({ relativeFilePath })
+  async loadOpencodeRules() {
+    const settablePaths = OpenCodeRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => OpenCodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => OpenCodeRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
   /**
-   * Load Cursor subagent configurations from .cursor/subagents/ directory
+   * Load Qwen Code rule configuration from QWEN.md file and .qwen/memories/*.md files
    */
-  async loadCursorSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: CursorSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => CursorSubagent.fromFile({ relativeFilePath })
+  async loadQwencodeRules() {
+    const settablePaths = QwencodeRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => QwencodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => QwencodeRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
   /**
-   * Load CodexCli subagent configurations from .codex/subagents/ directory
+   * Load Roo Code rule configurations from .roo/rules/ directory
    */
-  async loadCodexCliSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: CodexCliSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => CodexCliSubagent.fromFile({ relativeFilePath })
+  async loadRooRules() {
+    const settablePaths = RooRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => RooRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
-  async loadToolSubagentsDefault({
-    relativeDirPath,
-    fromFile
-  }) {
-    const paths = await findFilesByGlobs(join52(this.baseDir, relativeDirPath, "*.md"));
-    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile(basename16(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
-    logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
-    return subagents;
+  /**
+   * Load Windsurf rule configurations from .windsurf/rules/ directory
+   */
+  async loadWindsurfRules() {
+    const settablePaths = WindsurfRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => WindsurfRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Implementation of abstract method from FeatureProcessor
    * Return the tool targets that this processor supports
    */
-  static getToolTargets({
-    includeSimulated = false
-  } = {}) {
-    if (!includeSimulated) {
-      return subagentsProcessorToolTargets.filter(
-        (target) => !subagentsProcessorToolTargetsSimulated.includes(target)
+  static getToolTargets() {
+    return rulesProcessorToolTargets;
+  }
+  generateXmlReferencesSection(toolRules) {
+    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
+    if (toolRulesWithoutRoot.length === 0) {
+      return "";
+    }
+    const lines = [];
+    lines.push(
+      "Please also reference the following documents as needed. In this case, `@` stands for the project root directory."
+    );
+    lines.push("");
+    const documentsData = {
+      Documents: {
+        Document: toolRulesWithoutRoot.map((rule) => {
+          const rulesyncRule = rule.toRulesyncRule();
+          const frontmatter = rulesyncRule.getFrontmatter();
+          const relativePath = `@${rule.getRelativePathFromCwd()}`;
+          const document = {
+            Path: relativePath
+          };
+          if (frontmatter.description) {
+            document.Description = frontmatter.description;
+          }
+          if (frontmatter.globs && frontmatter.globs.length > 0) {
+            document.FilePatterns = frontmatter.globs.join(", ");
+          }
+          return document;
+        })
+      }
+    };
+    const builder = new XMLBuilder({
+      format: true,
+      ignoreAttributes: false,
+      suppressEmptyNode: false
+    });
+    const xmlContent = builder.build(documentsData);
+    lines.push(xmlContent);
+    return lines.join("\n") + "\n";
+  }
+  generateReferencesSection(toolRules) {
+    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
+    if (toolRulesWithoutRoot.length === 0) {
+      return "";
+    }
+    const lines = [];
+    lines.push("Please also reference the following documents as needed:");
+    lines.push("");
+    for (const rule of toolRulesWithoutRoot) {
+      const rulesyncRule = rule.toRulesyncRule();
+      const frontmatter = rulesyncRule.getFrontmatter();
+      const escapedDescription = frontmatter.description?.replace(/"/g, '\\"');
+      const globsText = frontmatter.globs?.join(",");
+      lines.push(
+        `@${rule.getRelativePathFromCwd()} description: "${escapedDescription}" globs: "${globsText}"`
       );
     }
-    return subagentsProcessorToolTargets;
+    return lines.join("\n") + "\n";
+  }
+  generateAdditionalConventionsSection({
+    commands,
+    subagents
+  }) {
+    const overview = `# Additional Conventions Beyond the Built-in Functions
+
+As this project's AI coding tool, you must follow the additional conventions below, in addition to the built-in functions.`;
+    const commandsSection = `## Simulated Custom Slash Commands
+
+Custom slash commands allow you to define frequently-used prompts as Markdown files that you can execute.
+
+### Syntax
+
+Users can use following syntax to invoke a custom command.
+
+\`\`\`txt
+s/<command> [arguments]
+\`\`\`
+
+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, \`${join52(commands.relativeDirPath, "{command}.md")}\`, then execute the contents of that file as the block of operations.`;
+    const subagentsSection = `## 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, \`${join52(subagents.relativeDirPath, "{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, \`${join52(subagents.relativeDirPath, "planner.md")}\`, and execute its contents as the block of operations.`;
+    const result = [
+      overview,
+      ...this.simulateCommands && CommandsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [commandsSection] : [],
+      ...this.simulateSubagents && SubagentsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [subagentsSection] : []
+    ].join("\n\n");
+    return result;
   }
 };
 
@@ -5798,6 +5922,7 @@ var gitignoreCommand = async () => {
     "**/GEMINI.md",
     "**/.gemini/memories/",
     "**/.gemini/commands/",
+    "**/.gemini/subagents/",
     "**/QWEN.md",
     "**/.qwen/memories/",
     "**/.aiexclude",
@@ -5815,6 +5940,7 @@ var gitignoreCommand = async () => {
     "**/.cursor/mcp.json",
     "**/.cline/mcp.json",
     "**/.roo/mcp.json",
+    "**/.roo/subagents/",
     "**/.vscode/mcp.json",
     "**/.github/commands/",
     "**/.github/subagents/",
@@ -5839,8 +5965,8 @@ var gitignoreCommand = async () => {
   }
   const newContent = gitignoreContent ? `${gitignoreContent.trimEnd()}
 
-${linesToAdd.join("")}
-` : `${linesToAdd.join("")}
+${linesToAdd.join("\n")}
+` : `${linesToAdd.join("\n")}
 `;
   await writeFileContent(gitignorePath, newContent);
   logger.success(`Added ${linesToAdd.length} rules to .gitignore:`);
@@ -6036,7 +6162,7 @@ var getVersion = async () => {
     const packageJson = await readJsonFile(packageJsonPath);
     return packageJson.version;
   } catch {
-    return "0.75.0";
+    return "0.76.0";
   }
 };
 var main = async () => {