rulesync 0.75.0 → 0.76.0

package/dist/index.cjs

@@ -765,7 +765,7 @@ var import_node_path7 = require("path");
 var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
   static getSettablePaths() {
     return {
-      relativeDirPath: ".copilot/commands"
+      relativeDirPath: ".github/commands"
     };
   }
   static fromRulesyncCommand({
@@ -1323,6 +1323,9 @@ var CommandsProcessor = class extends FeatureProcessor {
     }
     return commandsProcessorToolTargets;
   }
+  static getToolTargetsSimulated() {
+    return commandsProcessorToolTargetsSimulated;
+  }
 };
 
 // src/config/config-resolver.ts
@@ -2800,9 +2803,9 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/rules/rules-processor.ts
-var import_node_path50 = require("path");
+var import_node_path53 = require("path");
 var import_fast_xml_parser = require("fast-xml-parser");
-var import_mini17 = require("zod/mini");
+var import_mini20 = require("zod/mini");
 
 // src/constants/paths.ts
 var import_node_path30 = require("path");
@@ -2960,7 +2963,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) {
@@ -3002,187 +3005,684 @@ 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
+var import_node_path34 = require("path");
+var import_mini15 = require("zod/mini");
+
+// src/subagents/claudecode-subagent.ts
 var import_node_path33 = require("path");
+var import_mini14 = require("zod/mini");
 
-// src/rules/rulesync-rule.ts
+// src/subagents/rulesync-subagent.ts
 var import_node_path32 = require("path");
 var import_mini13 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini13.z.object({
-  root: import_mini13.z.optional(import_mini13.z.optional(import_mini13.z.boolean())),
-  targets: import_mini13.z.optional(RulesyncTargetsSchema),
-  description: import_mini13.z.optional(import_mini13.z.string()),
-  globs: import_mini13.z.optional(import_mini13.z.array(import_mini13.z.string())),
-  cursor: import_mini13.z.optional(
+var RulesyncSubagentModelSchema = import_mini13.z.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = import_mini13.z.object({
+  targets: RulesyncTargetsSchema,
+  name: import_mini13.z.string(),
+  description: import_mini13.z.string(),
+  claudecode: import_mini13.z.optional(
     import_mini13.z.object({
-      alwaysApply: import_mini13.z.optional(import_mini13.z.boolean()),
-      description: import_mini13.z.optional(import_mini13.z.string()),
-      globs: import_mini13.z.optional(import_mini13.z.array(import_mini13.z.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 = (0, import_node_path32.join)(this.getSettablePaths().legacy.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(filePath);
+    const fileContent = await readFileContent((0, import_node_path32.join)(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 = (0, import_node_path32.basename)(filePath);
-    return new _RulesyncRule({
+    const filename = (0, import_node_path32.basename)(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 = (0, import_node_path32.join)(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 = import_mini14.z.object({
+  name: import_mini14.z.string(),
+  description: import_mini14.z.string(),
+  model: import_mini14.z.optional(import_mini14.z.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 = (0, import_node_path32.basename)(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;
+    const fileContent = await readFileContent((0, import_node_path33.join)(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("*")) {
-      return true;
+    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 = import_mini15.z.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 = (0, import_node_path34.join)(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 = (0, import_node_path34.join)(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((0, import_node_path34.join)(this.baseDir, relativeDirPath, "*.md"));
+    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile((0, import_node_path34.basename)(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
+var import_node_path36 = require("path");
+
+// src/rules/rulesync-rule.ts
+var import_node_path35 = require("path");
+var import_mini16 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini16.z.object({
+  root: import_mini16.z.optional(import_mini16.z.optional(import_mini16.z.boolean())),
+  targets: import_mini16.z.optional(RulesyncTargetsSchema),
+  description: import_mini16.z.optional(import_mini16.z.string()),
+  globs: import_mini16.z.optional(import_mini16.z.array(import_mini16.z.string())),
+  cursor: import_mini16.z.optional(
+    import_mini16.z.object({
+      alwaysApply: import_mini16.z.optional(import_mini16.z.boolean()),
+      description: import_mini16.z.optional(import_mini16.z.string()),
+      globs: import_mini16.z.optional(import_mini16.z.array(import_mini16.z.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 = (0, import_node_path35.join)(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 = (0, import_node_path35.basename)(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 = (0, import_node_path35.join)(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 = (0, import_node_path35.basename)(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;
@@ -3217,8 +3717,8 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path33.join)(".agents/memories", relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path33.join)(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path36.join)(".agents/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path36.join)(baseDir, relativePath));
     return new _AgentsMdRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3258,7 +3758,7 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 };
 
 // src/rules/amazonqcli-rule.ts
-var import_node_path34 = require("path");
+var import_node_path37 = require("path");
 var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3273,7 +3773,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path34.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      (0, import_node_path37.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _AmazonQCliRule({
       baseDir,
@@ -3313,7 +3813,7 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 };
 
 // src/rules/augmentcode-legacy-rule.ts
-var import_node_path35 = require("path");
+var import_node_path38 = require("path");
 var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   toRulesyncRule() {
     const rulesyncFrontmatter = {
@@ -3373,8 +3873,8 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
   }) {
     const settablePaths = this.getSettablePaths();
     const isRoot = relativeFilePath === settablePaths.root.relativeFilePath;
-    const relativePath = isRoot ? settablePaths.root.relativeFilePath : (0, import_node_path35.join)(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path35.join)(baseDir, relativePath));
+    const relativePath = isRoot ? settablePaths.root.relativeFilePath : (0, import_node_path38.join)(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path38.join)(baseDir, relativePath));
     return new _AugmentcodeLegacyRule({
       baseDir,
       relativeDirPath: isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath,
@@ -3387,7 +3887,7 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
 };
 
 // src/rules/augmentcode-rule.ts
-var import_node_path36 = require("path");
+var import_node_path39 = require("path");
 var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   toRulesyncRule() {
     return this.toRulesyncRuleDefault();
@@ -3419,7 +3919,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path36.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      (0, import_node_path39.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     const { body: content } = parseFrontmatter(fileContent);
     return new _AugmentcodeRule({
@@ -3442,7 +3942,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
 };
 
 // src/rules/claudecode-rule.ts
-var import_node_path37 = require("path");
+var import_node_path40 = require("path");
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3461,8 +3961,8 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : (0, import_node_path37.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path37.join)(baseDir, relativePath));
+    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : (0, import_node_path40.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path40.join)(baseDir, relativePath));
     return new _ClaudecodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3502,10 +4002,10 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 };
 
 // src/rules/cline-rule.ts
-var import_node_path38 = require("path");
-var import_mini14 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini14.z.object({
-  description: import_mini14.z.string()
+var import_node_path41 = require("path");
+var import_mini17 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini17.z.object({
+  description: import_mini17.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -3547,7 +4047,7 @@ var ClineRule = class _ClineRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path38.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      (0, import_node_path41.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _ClineRule({
       baseDir,
@@ -3560,7 +4060,7 @@ var ClineRule = class _ClineRule extends ToolRule {
 };
 
 // src/rules/codexcli-rule.ts
-var import_node_path39 = require("path");
+var import_node_path42 = require("path");
 var CodexcliRule = class _CodexcliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3579,8 +4079,8 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path39.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path39.join)(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path42.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path42.join)(baseDir, relativePath));
     return new _CodexcliRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3620,11 +4120,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 };
 
 // src/rules/copilot-rule.ts
-var import_node_path40 = require("path");
-var import_mini15 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini15.z.object({
-  description: import_mini15.z.optional(import_mini15.z.string()),
-  applyTo: import_mini15.z.optional(import_mini15.z.string())
+var import_node_path43 = require("path");
+var import_mini18 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini18.z.object({
+  description: import_mini18.z.optional(import_mini18.z.string()),
+  applyTo: import_mini18.z.optional(import_mini18.z.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -3712,11 +4212,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "copilot-instructions.md";
-    const relativePath = isRoot ? (0, import_node_path40.join)(
+    const relativePath = isRoot ? (0, import_node_path43.join)(
       this.getSettablePaths().root.relativeDirPath,
       this.getSettablePaths().root.relativeFilePath
-    ) : (0, import_node_path40.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path40.join)(baseDir, relativePath));
+    ) : (0, import_node_path43.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path43.join)(baseDir, relativePath));
     if (isRoot) {
       return new _CopilotRule({
         baseDir,
@@ -3735,7 +4235,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path40.join)(baseDir, relativeFilePath)}: ${result.error.message}`
+        `Invalid frontmatter in ${(0, import_node_path43.join)(baseDir, relativeFilePath)}: ${result.error.message}`
       );
     }
     return new _CopilotRule({
@@ -3774,12 +4274,12 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 };
 
 // src/rules/cursor-rule.ts
-var import_node_path41 = require("path");
-var import_mini16 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini16.z.object({
-  description: import_mini16.z.optional(import_mini16.z.string()),
-  globs: import_mini16.z.optional(import_mini16.z.string()),
-  alwaysApply: import_mini16.z.optional(import_mini16.z.boolean())
+var import_node_path44 = require("path");
+var import_mini19 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini19.z.object({
+  description: import_mini19.z.optional(import_mini19.z.string()),
+  globs: import_mini19.z.optional(import_mini19.z.string()),
+  alwaysApply: import_mini19.z.optional(import_mini19.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -3904,19 +4404,19 @@ var CursorRule = class _CursorRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path41.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      (0, import_node_path44.join)(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 ${(0, import_node_path41.join)(baseDir, relativeFilePath)}: ${result.error.message}`
+        `Invalid frontmatter in ${(0, import_node_path44.join)(baseDir, relativeFilePath)}: ${result.error.message}`
       );
     }
     return new _CursorRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: (0, import_node_path41.basename)(relativeFilePath),
+      relativeFilePath: (0, import_node_path44.basename)(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -3948,7 +4448,7 @@ var CursorRule = class _CursorRule extends ToolRule {
 };
 
 // src/rules/geminicli-rule.ts
-var import_node_path42 = require("path");
+var import_node_path45 = require("path");
 var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3967,8 +4467,8 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "GEMINI.md";
-    const relativePath = isRoot ? "GEMINI.md" : (0, import_node_path42.join)(".gemini/memories", relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path42.join)(baseDir, relativePath));
+    const relativePath = isRoot ? "GEMINI.md" : (0, import_node_path45.join)(".gemini/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path45.join)(baseDir, relativePath));
     return new _GeminiCliRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4008,7 +4508,7 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
 };
 
 // src/rules/junie-rule.ts
-var import_node_path43 = require("path");
+var import_node_path46 = require("path");
 var JunieRule = class _JunieRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4027,8 +4527,8 @@ var JunieRule = class _JunieRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "guidelines.md";
-    const relativePath = isRoot ? "guidelines.md" : (0, import_node_path43.join)(".junie/memories", relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path43.join)(baseDir, relativePath));
+    const relativePath = isRoot ? "guidelines.md" : (0, import_node_path46.join)(".junie/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path46.join)(baseDir, relativePath));
     return new _JunieRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4068,7 +4568,7 @@ var JunieRule = class _JunieRule extends ToolRule {
 };
 
 // src/rules/kiro-rule.ts
-var import_node_path44 = require("path");
+var import_node_path47 = require("path");
 var KiroRule = class _KiroRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4083,7 +4583,7 @@ var KiroRule = class _KiroRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path44.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      (0, import_node_path47.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _KiroRule({
       baseDir,
@@ -4123,7 +4623,7 @@ var KiroRule = class _KiroRule extends ToolRule {
 };
 
 // src/rules/opencode-rule.ts
-var import_node_path45 = require("path");
+var import_node_path48 = require("path");
 var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4142,8 +4642,8 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path45.join)(".opencode/memories", relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path45.join)(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : (0, import_node_path48.join)(".opencode/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path48.join)(baseDir, relativePath));
     return new _OpenCodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4183,7 +4683,7 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
 };
 
 // src/rules/qwencode-rule.ts
-var import_node_path46 = require("path");
+var import_node_path49 = require("path");
 var QwencodeRule = class _QwencodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4202,8 +4702,8 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "QWEN.md";
-    const relativePath = isRoot ? "QWEN.md" : (0, import_node_path46.join)(".qwen/memories", relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path46.join)(baseDir, relativePath));
+    const relativePath = isRoot ? "QWEN.md" : (0, import_node_path49.join)(".qwen/memories", relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path49.join)(baseDir, relativePath));
     return new _QwencodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4240,7 +4740,7 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
 };
 
 // src/rules/roo-rule.ts
-var import_node_path47 = require("path");
+var import_node_path50 = require("path");
 var RooRule = class _RooRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4255,7 +4755,7 @@ var RooRule = class _RooRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path47.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      (0, import_node_path50.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _RooRule({
       baseDir,
@@ -4310,7 +4810,7 @@ var RooRule = class _RooRule extends ToolRule {
 };
 
 // src/rules/warp-rule.ts
-var import_node_path48 = require("path");
+var import_node_path51 = require("path");
 var WarpRule = class _WarpRule extends ToolRule {
   constructor({ fileContent, root, ...rest }) {
     super({
@@ -4336,8 +4836,8 @@ var WarpRule = class _WarpRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : (0, import_node_path48.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path48.join)(baseDir, relativePath));
+    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : (0, import_node_path51.join)(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent((0, import_node_path51.join)(baseDir, relativePath));
     return new _WarpRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : ".warp",
@@ -4377,7 +4877,7 @@ var WarpRule = class _WarpRule extends ToolRule {
 };
 
 // src/rules/windsurf-rule.ts
-var import_node_path49 = require("path");
+var import_node_path52 = require("path");
 var WindsurfRule = class _WindsurfRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4392,7 +4892,7 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path49.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      (0, import_node_path52.join)(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _WindsurfRule({
       baseDir,
@@ -4450,7 +4950,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini17.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini20.z.enum(rulesProcessorToolTargets);
 var RulesProcessor = class extends FeatureProcessor {
   toolTarget;
   simulateCommands;
@@ -4629,7 +5129,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,
@@ -4648,6 +5149,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;
@@ -4701,7 +5218,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;
       }
@@ -4749,17 +5271,17 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    const files = await findFilesByGlobs((0, import_node_path50.join)(RULESYNC_RULES_DIR, "*.md"));
+    const files = await findFilesByGlobs((0, import_node_path53.join)(RULESYNC_RULES_DIR, "*.md"));
     logger.debug(`Found ${files.length} rulesync files`);
     return Promise.all(
-      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: (0, import_node_path50.basename)(file) }))
+      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: (0, import_node_path53.basename)(file) }))
     );
   }
   async loadRulesyncFilesLegacy() {
-    const legacyFiles = await findFilesByGlobs((0, import_node_path50.join)(RULESYNC_RULES_DIR_LEGACY, "*.md"));
+    const legacyFiles = await findFilesByGlobs((0, import_node_path53.join)(RULESYNC_RULES_DIR_LEGACY, "*.md"));
     logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
     return Promise.all(
-      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: (0, import_node_path50.basename)(file) }))
+      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: (0, import_node_path53.basename)(file) }))
     );
   }
   /**
@@ -4820,803 +5342,405 @@ var RulesProcessor = class extends FeatureProcessor {
         return [];
       }
       const rootFilePaths = await findFilesByGlobs(
-        (0, import_node_path50.join)(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
+        (0, import_node_path53.join)(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
       );
       return await Promise.all(
         rootFilePaths.map(
           (filePath) => root.fromFile({
             baseDir: this.baseDir,
-            relativeFilePath: (0, import_node_path50.basename)(filePath)
-          })
-        )
-      );
-    })();
-    logger.debug(`Found ${rootToolRules.length} root tool rule files`);
-    const nonRootToolRules = await (async () => {
-      if (!nonRoot) {
-        return [];
-      }
-      const nonRootFilePaths = await findFilesByGlobs(
-        (0, import_node_path50.join)(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
-      );
-      return await Promise.all(
-        nonRootFilePaths.map(
-          (filePath) => nonRoot.fromFile({
-            baseDir: this.baseDir,
-            relativeFilePath: (0, import_node_path50.basename)(filePath)
+            relativeFilePath: (0, import_node_path53.basename)(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(
+        (0, import_node_path53.join)(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
+      );
+      return await Promise.all(
+        nonRootFilePaths.map(
+          (filePath) => nonRoot.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: (0, import_node_path53.basename)(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 import_fast_xml_parser.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, \`${(0, import_node_path50.join)(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, \`${(0, import_node_path50.join)(subagents.relativeDirPath, "{subagent}.md")}\`, and execute its contents as the block of operations.` : ""}`.trim();
-  }
-};
-
-// src/subagents/subagents-processor.ts
-var import_node_path53 = require("path");
-var import_mini20 = require("zod/mini");
-
-// src/subagents/claudecode-subagent.ts
-var import_node_path52 = require("path");
-var import_mini19 = require("zod/mini");
-
-// src/subagents/rulesync-subagent.ts
-var import_node_path51 = require("path");
-var import_mini18 = require("zod/mini");
-var RulesyncSubagentModelSchema = import_mini18.z.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = import_mini18.z.object({
-  targets: RulesyncTargetsSchema,
-  name: import_mini18.z.string(),
-  description: import_mini18.z.string(),
-  claudecode: import_mini18.z.optional(
-    import_mini18.z.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((0, import_node_path51.join)(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 = (0, import_node_path51.basename)(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 = import_mini19.z.object({
-  name: import_mini19.z.string(),
-  description: import_mini19.z.string(),
-  model: import_mini19.z.optional(import_mini19.z.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((0, import_node_path52.join)(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 = import_mini20.z.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 = (0, import_node_path53.join)(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 = (0, import_node_path53.join)(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((0, import_node_path53.join)(this.baseDir, relativeDirPath, "*.md"));
-    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile((0, import_node_path53.basename)(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 import_fast_xml_parser.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, \`${(0, import_node_path53.join)(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, \`${(0, import_node_path53.join)(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, \`${(0, import_node_path53.join)(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;
   }
 };
 
@@ -5821,6 +5945,7 @@ var gitignoreCommand = async () => {
     "**/GEMINI.md",
     "**/.gemini/memories/",
     "**/.gemini/commands/",
+    "**/.gemini/subagents/",
     "**/QWEN.md",
     "**/.qwen/memories/",
     "**/.aiexclude",
@@ -5838,6 +5963,7 @@ var gitignoreCommand = async () => {
     "**/.cursor/mcp.json",
     "**/.cline/mcp.json",
     "**/.roo/mcp.json",
+    "**/.roo/subagents/",
     "**/.vscode/mcp.json",
     "**/.github/commands/",
     "**/.github/subagents/",
@@ -5862,8 +5988,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:`);
@@ -6060,7 +6186,7 @@ var getVersion = async () => {
     const packageJson = await readJsonFile(packageJsonPath);
     return packageJson.version;
   } catch {
-    return "0.75.0";
+    return "0.76.0";
   }
 };
 var main = async () => {