rulesync 0.74.0 → 0.76.0

package/dist/index.js

@@ -8,98 +8,13 @@ import { Command } from "commander";
 // src/constants/announcements.ts
 var ANNOUNCEMENT = "".trim();
 
-// src/types/config-options.ts
-import { z as z2 } from "zod/mini";
-
-// src/types/tool-targets.ts
+// src/types/features.ts
 import { z } from "zod/mini";
-var ALL_TOOL_TARGETS = [
-  "agentsmd",
-  "amazonqcli",
-  "augmentcode",
-  "augmentcode-legacy",
-  "copilot",
-  "cursor",
-  "cline",
-  "claudecode",
-  "codexcli",
-  "opencode",
-  "qwencode",
-  "roo",
-  "geminicli",
-  "kiro",
-  "junie",
-  "warp",
-  "windsurf"
-];
-var ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
-var ToolTargetSchema = z.enum(ALL_TOOL_TARGETS);
-var ToolTargetsSchema = z.array(ToolTargetSchema);
-var RulesyncTargetsSchema = z.array(z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
-
-// src/types/config-options.ts
-var FEATURE_TYPES = ["rules", "commands", "mcp", "ignore", "subagents"];
-var FeatureTypeSchema = z2.enum(FEATURE_TYPES);
-var FeaturesSchema = z2.union([z2.array(FeatureTypeSchema), z2.literal("*")]);
-var OutputPathsSchema = z2.object({
-  agentsmd: z2.optional(z2.string()),
-  amazonqcli: z2.optional(z2.string()),
-  augmentcode: z2.optional(z2.string()),
-  "augmentcode-legacy": z2.optional(z2.string()),
-  copilot: z2.optional(z2.string()),
-  cursor: z2.optional(z2.string()),
-  cline: z2.optional(z2.string()),
-  claudecode: z2.optional(z2.string()),
-  codexcli: z2.optional(z2.string()),
-  opencode: z2.optional(z2.string()),
-  qwencode: z2.optional(z2.string()),
-  roo: z2.optional(z2.string()),
-  geminicli: z2.optional(z2.string()),
-  kiro: z2.optional(z2.string()),
-  junie: z2.optional(z2.string()),
-  windsurf: z2.optional(z2.string())
-});
-var ConfigOptionsSchema = z2.object({
-  aiRulesDir: z2.optional(z2.string()),
-  outputPaths: z2.optional(OutputPathsSchema),
-  watchEnabled: z2.optional(z2.boolean()),
-  defaultTargets: z2.optional(ToolTargetsSchema),
-  targets: z2.optional(z2.array(ToolTargetSchema)),
-  exclude: z2.optional(z2.array(ToolTargetSchema)),
-  features: z2.optional(FeaturesSchema),
-  verbose: z2.optional(z2.boolean()),
-  delete: z2.optional(z2.boolean()),
-  baseDir: z2.optional(z2.union([z2.string(), z2.array(z2.string())])),
-  legacy: z2.optional(z2.boolean()),
-  watch: z2.optional(
-    z2.object({
-      enabled: z2.optional(z2.boolean()),
-      interval: z2.optional(z2.number()),
-      ignore: z2.optional(z2.array(z2.string()))
-    })
-  )
-});
-var MergedConfigSchema = z2.object({
-  aiRulesDir: z2.string(),
-  outputPaths: z2.record(ToolTargetSchema, z2.string()),
-  watchEnabled: z2.boolean(),
-  defaultTargets: ToolTargetsSchema,
-  targets: z2.optional(z2.array(ToolTargetSchema)),
-  exclude: z2.optional(z2.array(ToolTargetSchema)),
-  features: z2.optional(FeaturesSchema),
-  verbose: z2.optional(z2.boolean()),
-  delete: z2.optional(z2.boolean()),
-  baseDir: z2.optional(z2.union([z2.string(), z2.array(z2.string())])),
-  configPath: z2.optional(z2.string()),
-  legacy: z2.optional(z2.boolean()),
-  watch: z2.optional(
-    z2.object({
-      enabled: z2.optional(z2.boolean()),
-      interval: z2.optional(z2.number()),
-      ignore: z2.optional(z2.array(z2.string()))
-    })
-  )
-});
+var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
+var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
+var FeatureSchema = z.enum(ALL_FEATURES);
+var FeaturesSchema = z.array(FeatureSchema);
+var RulesyncFeaturesSchema = z.array(z.enum(ALL_FEATURES_WITH_WILDCARD));
 
 // src/utils/file.ts
 import { globSync } from "fs";
@@ -407,6 +322,32 @@ var RulesyncFile = class extends AiFile {
   }
 };
 
+// src/types/tool-targets.ts
+import { z as z2 } from "zod/mini";
+var ALL_TOOL_TARGETS = [
+  "agentsmd",
+  "amazonqcli",
+  "augmentcode",
+  "augmentcode-legacy",
+  "copilot",
+  "cursor",
+  "cline",
+  "claudecode",
+  "codexcli",
+  "opencode",
+  "qwencode",
+  "roo",
+  "geminicli",
+  "kiro",
+  "junie",
+  "warp",
+  "windsurf"
+];
+var ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
+var ToolTargetSchema = z2.enum(ALL_TOOL_TARGETS);
+var ToolTargetsSchema = z2.array(ToolTargetSchema);
+var RulesyncTargetsSchema = z2.array(z2.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
+
 // src/commands/rulesync-command.ts
 var RulesyncCommandFrontmatterSchema = z3.object({
   targets: RulesyncTargetsSchema,
@@ -509,6 +450,39 @@ var ToolCommand = class extends AiFile {
   static fromRulesyncCommand(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
+  /**
+   * Check if this tool is targeted by a RulesyncCommand based on its targets field.
+   * Subclasses should override this to provide specific targeting logic.
+   *
+   * @param rulesyncCommand - The RulesyncCommand to check
+   * @returns True if this tool is targeted by the command
+   */
+  static isTargetedByRulesyncCommand(_rulesyncCommand) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  /**
+   * Default implementation for checking if a tool is targeted by a RulesyncCommand.
+   * Checks if the command's targets include the tool target or a wildcard.
+   *
+   * @param params - Parameters including the RulesyncCommand and tool target
+   * @returns True if the tool target is included in the command's targets
+   */
+  static isTargetedByRulesyncCommandDefault({
+    rulesyncCommand,
+    toolTarget
+  }) {
+    const targets = rulesyncCommand.getFrontmatter().targets;
+    if (!targets) {
+      return true;
+    }
+    if (targets.includes("*")) {
+      return true;
+    }
+    if (targets.includes(toolTarget)) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/commands/claudecode-command.ts
@@ -589,6 +563,12 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
       return { success: false, error: result.error };
     }
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "claudecode"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
@@ -749,6 +729,12 @@ var CodexCliCommand = class _CodexCliCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "codexcli"
+    });
+  }
 };
 
 // src/commands/copilot-command.ts
@@ -756,7 +742,7 @@ import { basename as basename6, join as join6 } from "path";
 var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
   static getSettablePaths() {
     return {
-      relativeDirPath: ".copilot/commands"
+      relativeDirPath: ".github/commands"
     };
   }
   static fromRulesyncCommand({
@@ -793,6 +779,12 @@ var CopilotCommand = class _CopilotCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "copilot"
+    });
+  }
 };
 
 // src/commands/cursor-command.ts
@@ -837,6 +829,12 @@ var CursorCommand = class _CursorCommand extends SimulatedCommand {
       validate
     });
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "cursor"
+    });
+  }
 };
 
 // src/commands/geminicli-command.ts
@@ -873,17 +871,6 @@ var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
       throw new Error(`Failed to parse TOML command file: ${error}`);
     }
   }
-  parseCommandFile(content) {
-    const parsed = this.parseTomlContent(content);
-    return {
-      filename: "unknown.toml",
-      filepath: "unknown.toml",
-      frontmatter: {
-        description: parsed.description
-      },
-      content: parsed.prompt
-    };
-  }
   getBody() {
     return this.body;
   }
@@ -958,6 +945,12 @@ ${geminiFrontmatter.prompt}
       return { success: false, error: error instanceof Error ? error : new Error(String(error)) };
     }
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "geminicli"
+    });
+  }
 };
 
 // src/commands/roo-command.ts
@@ -1043,6 +1036,12 @@ var RooCommand = class _RooCommand extends ToolCommand {
       return { success: false, error: result.error };
     }
   }
+  static isTargetedByRulesyncCommand(rulesyncCommand) {
+    return this.isTargetedByRulesyncCommandDefault({
+      rulesyncCommand,
+      toolTarget: "roo"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
@@ -1094,31 +1093,49 @@ var CommandsProcessor = class extends FeatureProcessor {
     const toolCommands = rulesyncCommands.map((rulesyncCommand) => {
       switch (this.toolTarget) {
         case "claudecode":
+          if (!ClaudecodeCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return ClaudecodeCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "geminicli":
+          if (!GeminiCliCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return GeminiCliCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "roo":
+          if (!RooCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return RooCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "copilot":
+          if (!CopilotCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return CopilotCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "cursor":
+          if (!CursorCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return CursorCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
           });
         case "codexcli":
+          if (!CodexCliCommand.isTargetedByRulesyncCommand(rulesyncCommand)) {
+            return null;
+          }
           return CodexCliCommand.fromRulesyncCommand({
             baseDir: this.baseDir,
             rulesyncCommand
@@ -1126,7 +1143,9 @@ var CommandsProcessor = class extends FeatureProcessor {
         default:
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
-    });
+    }).filter(
+      (command) => command !== null
+    );
     return toolCommands;
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -1281,19 +1300,14 @@ var CommandsProcessor = class extends FeatureProcessor {
     }
     return commandsProcessorToolTargets;
   }
+  static getToolTargetsSimulated() {
+    return commandsProcessorToolTargetsSimulated;
+  }
 };
 
 // src/config/config-resolver.ts
 import { loadConfig } from "c12";
 
-// src/types/features.ts
-import { z as z9 } from "zod/mini";
-var ALL_FEATURES = ["rules", "ignore", "mcp", "subagents", "commands"];
-var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
-var FeatureSchema = z9.enum(ALL_FEATURES);
-var FeaturesSchema2 = z9.array(FeatureSchema);
-var RulesyncFeaturesSchema = z9.array(z9.enum(ALL_FEATURES_WITH_WILDCARD));
-
 // src/config/config.ts
 var Config = class {
   baseDirs;
@@ -1408,7 +1422,7 @@ var ConfigResolver = class {
 };
 
 // src/ignore/ignore-processor.ts
-import { z as z10 } from "zod/mini";
+import { z as z9 } from "zod/mini";
 
 // src/ignore/amazonqcli-ignore.ts
 import { join as join11 } from "path";
@@ -2020,7 +2034,7 @@ var ignoreProcessorToolTargets = [
   "roo",
   "windsurf"
 ];
-var IgnoreProcessorToolTargetSchema = z10.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = z9.enum(ignoreProcessorToolTargets);
 var IgnoreProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2182,47 +2196,40 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/mcp/mcp-processor.ts
-import { z as z12 } from "zod/mini";
+import { z as z11 } from "zod/mini";
 
 // src/mcp/amazonqcli-mcp.ts
 import { join as join23 } from "path";
 
 // src/mcp/rulesync-mcp.ts
 import { join as join22 } from "path";
-
-// src/types/mcp.ts
-import { z as z11 } from "zod/mini";
-var McpTransportTypeSchema = z11.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = z11.object({
-  type: z11.optional(z11.enum(["stdio", "sse", "http"])),
-  command: z11.optional(z11.union([z11.string(), z11.array(z11.string())])),
-  args: z11.optional(z11.array(z11.string())),
-  url: z11.optional(z11.string()),
-  httpUrl: z11.optional(z11.string()),
-  env: z11.optional(z11.record(z11.string(), z11.string())),
-  disabled: z11.optional(z11.boolean()),
-  networkTimeout: z11.optional(z11.number()),
-  timeout: z11.optional(z11.number()),
-  trust: z11.optional(z11.boolean()),
-  cwd: z11.optional(z11.string()),
-  transport: z11.optional(McpTransportTypeSchema),
-  alwaysAllow: z11.optional(z11.array(z11.string())),
-  tools: z11.optional(z11.array(z11.string())),
-  kiroAutoApprove: z11.optional(z11.array(z11.string())),
-  kiroAutoBlock: z11.optional(z11.array(z11.string())),
-  headers: z11.optional(z11.record(z11.string(), z11.string()))
-});
-var RulesyncMcpServerSchema = z11.extend(McpServerBaseSchema, {
-  targets: z11.optional(RulesyncTargetsSchema)
+import { z as z10 } from "zod/mini";
+var McpTransportTypeSchema = z10.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = z10.object({
+  type: z10.optional(z10.enum(["stdio", "sse", "http"])),
+  command: z10.optional(z10.union([z10.string(), z10.array(z10.string())])),
+  args: z10.optional(z10.array(z10.string())),
+  url: z10.optional(z10.string()),
+  httpUrl: z10.optional(z10.string()),
+  env: z10.optional(z10.record(z10.string(), z10.string())),
+  disabled: z10.optional(z10.boolean()),
+  networkTimeout: z10.optional(z10.number()),
+  timeout: z10.optional(z10.number()),
+  trust: z10.optional(z10.boolean()),
+  cwd: z10.optional(z10.string()),
+  transport: z10.optional(McpTransportTypeSchema),
+  alwaysAllow: z10.optional(z10.array(z10.string())),
+  tools: z10.optional(z10.array(z10.string())),
+  kiroAutoApprove: z10.optional(z10.array(z10.string())),
+  kiroAutoBlock: z10.optional(z10.array(z10.string())),
+  headers: z10.optional(z10.record(z10.string(), z10.string()))
 });
-var McpConfigSchema = z11.object({
-  mcpServers: z11.record(z11.string(), McpServerBaseSchema)
+var RulesyncMcpServerSchema = z10.extend(McpServerBaseSchema, {
+  targets: z10.optional(RulesyncTargetsSchema)
 });
-var RulesyncMcpConfigSchema = z11.object({
-  mcpServers: z11.record(z11.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = z10.object({
+  mcpServers: z10.record(z10.string(), RulesyncMcpServerSchema)
 });
-
-// src/mcp/rulesync-mcp.ts
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
   json;
   constructor({ ...rest }) {
@@ -2614,7 +2621,7 @@ var mcpProcessorToolTargets = [
   "cursor",
   "roo"
 ];
-var McpProcessorToolTargetSchema = z12.enum(mcpProcessorToolTargets);
+var McpProcessorToolTargetSchema = z11.enum(mcpProcessorToolTargets);
 var McpProcessor = class extends FeatureProcessor {
   toolTarget;
   constructor({
@@ -2773,9 +2780,9 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/rules/rules-processor.ts
-import { basename as basename14, join as join49 } from "path";
+import { basename as basename16, join as join52 } from "path";
 import { XMLBuilder } from "fast-xml-parser";
-import { z as z18 } from "zod/mini";
+import { z as z20 } from "zod/mini";
 
 // src/constants/paths.ts
 import { join as join29 } from "path";
@@ -2787,7 +2794,7 @@ var RULESYNC_SUBAGENTS_DIR = join29(".rulesync", "subagents");
 
 // src/subagents/simulated-subagent.ts
 import { basename as basename11, join as join30 } from "path";
-import { z as z13 } from "zod/mini";
+import { z as z12 } from "zod/mini";
 
 // src/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -2800,12 +2807,31 @@ var ToolSubagent = class extends ToolFile {
   static fromRulesyncSubagent(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
+  static isTargetedByRulesyncSubagent(_rulesyncSubagent) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static isTargetedByRulesyncSubagentDefault({
+    rulesyncSubagent,
+    toolTarget
+  }) {
+    const targets = rulesyncSubagent.getFrontmatter().targets;
+    if (!targets) {
+      return true;
+    }
+    if (targets.includes("*")) {
+      return true;
+    }
+    if (targets.includes(toolTarget)) {
+      return true;
+    }
+    return false;
+  }
 };
 
 // src/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z13.object({
-  name: z13.string(),
-  description: z13.string()
+var SimulatedSubagentFrontmatterSchema = z12.object({
+  name: z12.string(),
+  description: z12.string()
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -2902,13 +2928,19 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
     const baseParams = this.fromRulesyncSubagentDefault(params);
     return new _CodexCliSubagent(baseParams);
   }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "codexcli"
+    });
+  }
 };
 
 // src/subagents/copilot-subagent.ts
 var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: ".copilot/subagents"
+      relativeDirPath: ".github/subagents"
     };
   }
   static async fromFile(params) {
@@ -2919,6 +2951,12 @@ var CopilotSubagent = class _CopilotSubagent extends SimulatedSubagent {
     const baseParams = this.fromRulesyncSubagentDefault(params);
     return new _CopilotSubagent(baseParams);
   }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "copilot"
+    });
+  }
 };
 
 // src/subagents/cursor-subagent.ts
@@ -2936,359 +2974,899 @@ var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
     const baseParams = this.fromRulesyncSubagentDefault(params);
     return new _CursorSubagent(baseParams);
   }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "cursor"
+    });
+  }
 };
 
-// src/rules/agentsmd-rule.ts
+// src/subagents/geminicli-subagent.ts
+var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".gemini/subagents"
+    };
+  }
+  static async fromFile(params) {
+    const baseParams = await this.fromFileDefault(params);
+    return new _GeminiCliSubagent(baseParams);
+  }
+  static fromRulesyncSubagent(params) {
+    const baseParams = this.fromRulesyncSubagentDefault(params);
+    return new _GeminiCliSubagent(baseParams);
+  }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "geminicli"
+    });
+  }
+};
+
+// src/subagents/roo-subagent.ts
+var RooSubagent = class _RooSubagent extends SimulatedSubagent {
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".roo/subagents"
+    };
+  }
+  static async fromFile(params) {
+    const baseParams = await this.fromFileDefault(params);
+    return new _RooSubagent(baseParams);
+  }
+  static fromRulesyncSubagent(params) {
+    const baseParams = this.fromRulesyncSubagentDefault(params);
+    return new _RooSubagent(baseParams);
+  }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "roo"
+    });
+  }
+};
+
+// src/subagents/subagents-processor.ts
+import { basename as basename13, join as join33 } from "path";
+import { z as z15 } from "zod/mini";
+
+// src/subagents/claudecode-subagent.ts
 import { join as join32 } from "path";
+import { z as z14 } from "zod/mini";
 
-// src/rules/rulesync-rule.ts
+// src/subagents/rulesync-subagent.ts
 import { basename as basename12, join as join31 } from "path";
-import { z as z14 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z14.object({
-  root: z14.optional(z14.optional(z14.boolean())),
-  targets: z14.optional(RulesyncTargetsSchema),
-  description: z14.optional(z14.string()),
-  globs: z14.optional(z14.array(z14.string())),
-  cursor: z14.optional(
-    z14.object({
-      alwaysApply: z14.optional(z14.boolean()),
-      description: z14.optional(z14.string()),
-      globs: z14.optional(z14.array(z14.string()))
+import { z as z13 } from "zod/mini";
+var RulesyncSubagentModelSchema = z13.enum(["opus", "sonnet", "haiku", "inherit"]);
+var RulesyncSubagentFrontmatterSchema = z13.object({
+  targets: RulesyncTargetsSchema,
+  name: z13.string(),
+  description: z13.string(),
+  claudecode: z13.optional(
+    z13.object({
+      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
-  }) {
-    const filePath = join31(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 = basename12(filePath);
-    return new _RulesyncRule({
-      baseDir: ".",
-      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
-      relativeFilePath: filename,
-      frontmatter: validatedFrontmatter,
-      body: content.trim(),
-      validate
-    });
-  }
   static async fromFile({
-    relativeFilePath,
-    validate = true
+    relativeFilePath
   }) {
-    const filePath = join31(this.getSettablePaths().recommended.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(filePath);
+    const fileContent = await readFileContent(join31(RULESYNC_SUBAGENTS_DIR, relativeFilePath));
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+    const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
     }
-    const validatedFrontmatter = {
-      root: result.data.root ?? false,
-      targets: result.data.targets ?? ["*"],
-      description: result.data.description ?? "",
-      globs: result.data.globs ?? [],
-      cursor: result.data.cursor
-    };
-    const filename = basename12(filePath);
-    return new _RulesyncRule({
+    const filename = basename12(relativeFilePath);
+    return new _RulesyncSubagent({
       baseDir: ".",
-      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
+      relativeDirPath: this.getSettablePaths().relativeDirPath,
       relativeFilePath: filename,
-      frontmatter: validatedFrontmatter,
+      frontmatter: result.data,
       body: content.trim(),
-      validate
+      fileContent
     });
   }
-  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;
-  }
-};
-
-// src/rules/agentsmd-rule.ts
-var AgentsMdRule = class _AgentsMdRule extends ToolRule {
-  constructor({ fileContent, root, ...rest }) {
+// src/subagents/claudecode-subagent.ts
+var ClaudecodeSubagentFrontmatterSchema = z14.object({
+  name: z14.string(),
+  description: z14.string(),
+  model: z14.optional(z14.enum(["opus", "sonnet", "haiku", "inherit"]))
+});
+var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw result.error;
+      }
+    }
     super({
-      ...rest,
-      fileContent,
-      root: root ?? false
+      ...rest
     });
+    this.frontmatter = frontmatter;
+    this.body = body;
   }
   static getSettablePaths() {
     return {
-      root: {
-        relativeDirPath: ".",
-        relativeFilePath: "AGENTS.md"
-      },
-      nonRoot: {
-        relativeDirPath: ".agents/memories"
-      }
+      relativeDirPath: ".claude/agents"
     };
   }
-  static async fromFile({
-    baseDir = ".",
-    relativeFilePath,
-    validate = true
-  }) {
-    const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join32(".agents/memories", relativeFilePath);
-    const fileContent = await readFileContent(join32(baseDir, relativePath));
-    return new _AgentsMdRule({
-      baseDir,
-      relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: isRoot ? "AGENTS.md" : relativeFilePath,
-      fileContent,
-      validate,
-      root: isRoot
-    });
-  }
-  static fromRulesyncRule({
-    baseDir = ".",
-    rulesyncRule,
-    validate = true
-  }) {
-    return new _AgentsMdRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        rootPath: this.getSettablePaths().root,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
-  }
-  toRulesyncRule() {
-    return this.toRulesyncRuleDefault();
+  getFrontmatter() {
+    return this.frontmatter;
   }
-  validate() {
-    return { success: true, error: null };
+  getBody() {
+    return this.body;
   }
-};
-
-// src/rules/amazonqcli-rule.ts
-import { join as join33 } from "path";
-var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
-  static getSettablePaths() {
-    return {
-      nonRoot: {
-        relativeDirPath: ".amazonq/rules"
+  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 async fromFile({
+  static fromRulesyncSubagent({
     baseDir = ".",
-    relativeFilePath,
+    rulesyncSubagent,
     validate = true
   }) {
-    const fileContent = await readFileContent(
-      join33(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
-    );
-    return new _AmazonQCliRule({
+    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: this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath,
+      frontmatter: claudecodeFrontmatter,
+      body,
+      relativeDirPath: ".claude/agents",
+      relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
       fileContent,
-      validate,
-      root: false
+      validate
     });
   }
-  static fromRulesyncRule({
-    baseDir = ".",
-    rulesyncRule,
-    validate = true
-  }) {
-    return new _AmazonQCliRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
-  }
-  toRulesyncRule() {
-    return this.toRulesyncRuleDefault();
-  }
   validate() {
-    return { success: true, error: null };
+    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 };
+    }
   }
-};
-
-// src/rules/augmentcode-legacy-rule.ts
-import { join as join34 } from "path";
-var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
-  toRulesyncRule() {
-    const rulesyncFrontmatter = {
-      root: this.isRoot(),
-      targets: ["*"],
-      description: "",
-      globs: this.isRoot() ? ["**/*"] : []
-    };
-    return new RulesyncRule({
-      baseDir: this.getBaseDir(),
-      frontmatter: rulesyncFrontmatter,
-      body: this.getFileContent(),
-      relativeDirPath: RULESYNC_RULES_DIR,
-      relativeFilePath: this.getRelativeFilePath(),
-      validate: true
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "claudecode"
     });
   }
-  static getSettablePaths() {
-    return {
-      root: {
-        relativeDirPath: ".",
-        relativeFilePath: ".augment-guidelines"
-      },
-      nonRoot: {
-        relativeDirPath: ".augment/rules"
-      }
-    };
-  }
-  static fromRulesyncRule({
-    baseDir = ".",
-    rulesyncRule,
-    validate = true
-  }) {
-    return new _AugmentcodeLegacyRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        rootPath: this.getSettablePaths().root,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
-  }
-  validate() {
-    return { success: true, error: null };
-  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
     validate = true
   }) {
-    const settablePaths = this.getSettablePaths();
-    const isRoot = relativeFilePath === settablePaths.root.relativeFilePath;
-    const relativePath = isRoot ? settablePaths.root.relativeFilePath : join34(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join34(baseDir, relativePath));
-    return new _AugmentcodeLegacyRule({
+    const fileContent = await readFileContent(join32(baseDir, ".claude/agents", relativeFilePath));
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
+    }
+    return new _ClaudecodeSubagent({
       baseDir,
-      relativeDirPath: isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath,
-      relativeFilePath: isRoot ? settablePaths.root.relativeFilePath : relativeFilePath,
+      relativeDirPath: ".claude/agents",
+      relativeFilePath,
+      frontmatter: result.data,
+      body: content.trim(),
       fileContent,
-      validate,
-      root: isRoot
+      validate
     });
   }
 };
 
-// src/rules/augmentcode-rule.ts
-import { join as join35 } from "path";
-var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
-  toRulesyncRule() {
+// src/subagents/subagents-processor.ts
+var subagentsProcessorToolTargets = [
+  "claudecode",
+  "copilot",
+  "cursor",
+  "codexcli",
+  "geminicli",
+  "roo"
+];
+var subagentsProcessorToolTargetsSimulated = [
+  "copilot",
+  "cursor",
+  "codexcli",
+  "geminicli",
+  "roo"
+];
+var SubagentsProcessorToolTargetSchema = z15.enum(subagentsProcessorToolTargets);
+var SubagentsProcessor = class extends FeatureProcessor {
+  toolTarget;
+  constructor({
+    baseDir = ".",
+    toolTarget
+  }) {
+    super({ baseDir });
+    this.toolTarget = SubagentsProcessorToolTargetSchema.parse(toolTarget);
+  }
+  async convertRulesyncFilesToToolFiles(rulesyncFiles) {
+    const rulesyncSubagents = rulesyncFiles.filter(
+      (file) => file instanceof RulesyncSubagent
+    );
+    const toolSubagents = rulesyncSubagents.map((rulesyncSubagent) => {
+      switch (this.toolTarget) {
+        case "claudecode":
+          if (!ClaudecodeSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return ClaudecodeSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "copilot":
+          if (!CopilotSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return CopilotSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "cursor":
+          if (!CursorSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return CursorSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "codexcli":
+          if (!CodexCliSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return CodexCliSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "geminicli":
+          if (!GeminiCliSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return GeminiCliSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        case "roo":
+          if (!RooSubagent.isTargetedByRulesyncSubagent(rulesyncSubagent)) {
+            return null;
+          }
+          return RooSubagent.fromRulesyncSubagent({
+            baseDir: this.baseDir,
+            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
+            rulesyncSubagent
+          });
+        default:
+          throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+      }
+    }).filter((subagent) => subagent !== null);
+    return toolSubagents;
+  }
+  async convertToolFilesToRulesyncFiles(toolFiles) {
+    const toolSubagents = toolFiles.filter(
+      (file) => file instanceof ToolSubagent
+    );
+    const rulesyncSubagents = [];
+    for (const toolSubagent of toolSubagents) {
+      if (toolSubagent instanceof SimulatedSubagent) {
+        logger.debug(
+          `Skipping simulated subagent conversion: ${toolSubagent.getRelativeFilePath()}`
+        );
+        continue;
+      }
+      rulesyncSubagents.push(toolSubagent.toRulesyncSubagent());
+    }
+    return rulesyncSubagents;
+  }
+  /**
+   * Implementation of abstract method from Processor
+   * Load and parse rulesync subagent files from .rulesync/subagents/ directory
+   */
+  async loadRulesyncFiles() {
+    const subagentsDir = join33(this.baseDir, RulesyncSubagent.getSettablePaths().relativeDirPath);
+    const dirExists = await directoryExists(subagentsDir);
+    if (!dirExists) {
+      logger.debug(`Rulesync subagents directory not found: ${subagentsDir}`);
+      return [];
+    }
+    const entries = await listDirectoryFiles(subagentsDir);
+    const mdFiles = entries.filter((file) => file.endsWith(".md"));
+    if (mdFiles.length === 0) {
+      logger.debug(`No markdown files found in rulesync subagents directory: ${subagentsDir}`);
+      return [];
+    }
+    logger.info(`Found ${mdFiles.length} subagent files in ${subagentsDir}`);
+    const rulesyncSubagents = [];
+    for (const mdFile of mdFiles) {
+      const filepath = join33(subagentsDir, mdFile);
+      try {
+        const rulesyncSubagent = await RulesyncSubagent.fromFile({
+          relativeFilePath: mdFile,
+          validate: true
+        });
+        rulesyncSubagents.push(rulesyncSubagent);
+        logger.debug(`Successfully loaded subagent: ${mdFile}`);
+      } catch (error) {
+        logger.warn(`Failed to load subagent file ${filepath}:`, error);
+        continue;
+      }
+    }
+    if (rulesyncSubagents.length === 0) {
+      logger.debug(`No valid subagents found in ${subagentsDir}`);
+      return [];
+    }
+    logger.info(`Successfully loaded ${rulesyncSubagents.length} rulesync subagents`);
+    return rulesyncSubagents;
+  }
+  /**
+   * Implementation of abstract method from Processor
+   * Load tool-specific subagent configurations and parse them into ToolSubagent instances
+   */
+  async loadToolFiles() {
+    switch (this.toolTarget) {
+      case "claudecode":
+        return await this.loadClaudecodeSubagents();
+      case "copilot":
+        return await this.loadCopilotSubagents();
+      case "cursor":
+        return await this.loadCursorSubagents();
+      case "codexcli":
+        return await this.loadCodexCliSubagents();
+      case "geminicli":
+        return await this.loadGeminiCliSubagents();
+      case "roo":
+        return await this.loadRooSubagents();
+      default:
+        throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+    }
+  }
+  /**
+   * Load Claude Code subagent configurations from .claude/agents/ directory
+   */
+  async loadClaudecodeSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: ClaudecodeSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => ClaudecodeSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load Copilot subagent configurations from .github/subagents/ directory
+   */
+  async loadCopilotSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: CopilotSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => CopilotSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load Cursor subagent configurations from .cursor/subagents/ directory
+   */
+  async loadCursorSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: CursorSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => CursorSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load CodexCli subagent configurations from .codex/subagents/ directory
+   */
+  async loadCodexCliSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: CodexCliSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => CodexCliSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load GeminiCli subagent configurations from .gemini/subagents/ directory
+   */
+  async loadGeminiCliSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: GeminiCliSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => GeminiCliSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  /**
+   * Load Roo subagent configurations from .roo/subagents/ directory
+   */
+  async loadRooSubagents() {
+    return await this.loadToolSubagentsDefault({
+      relativeDirPath: RooSubagent.getSettablePaths().relativeDirPath,
+      fromFile: (relativeFilePath) => RooSubagent.fromFile({ relativeFilePath })
+    });
+  }
+  async loadToolSubagentsDefault({
+    relativeDirPath,
+    fromFile
+  }) {
+    const paths = await findFilesByGlobs(join33(this.baseDir, relativeDirPath, "*.md"));
+    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile(basename13(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
+    logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
+    return subagents;
+  }
+  /**
+   * Implementation of abstract method from FeatureProcessor
+   * Return the tool targets that this processor supports
+   */
+  static getToolTargets({
+    includeSimulated = false
+  } = {}) {
+    if (!includeSimulated) {
+      return subagentsProcessorToolTargets.filter(
+        (target) => !subagentsProcessorToolTargetsSimulated.includes(target)
+      );
+    }
+    return subagentsProcessorToolTargets;
+  }
+  static getToolTargetsSimulated() {
+    return subagentsProcessorToolTargetsSimulated;
+  }
+};
+
+// src/rules/agentsmd-rule.ts
+import { join as join35 } from "path";
+
+// src/rules/rulesync-rule.ts
+import { basename as basename14, join as join34 } from "path";
+import { z as z16 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z16.object({
+  root: z16.optional(z16.optional(z16.boolean())),
+  targets: z16.optional(RulesyncTargetsSchema),
+  description: z16.optional(z16.string()),
+  globs: z16.optional(z16.array(z16.string())),
+  cursor: z16.optional(
+    z16.object({
+      alwaysApply: z16.optional(z16.boolean()),
+      description: z16.optional(z16.string()),
+      globs: z16.optional(z16.array(z16.string()))
+    })
+  )
+});
+var RulesyncRule = class _RulesyncRule extends RulesyncFile {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw result.error;
+      }
+    }
+    super({
+      ...rest,
+      fileContent: stringifyFrontmatter(body, frontmatter)
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
+  static getSettablePaths() {
+    return {
+      recommended: {
+        relativeDirPath: ".rulesync/rules"
+      },
+      legacy: {
+        relativeDirPath: ".rulesync"
+      }
+    };
+  }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = RulesyncRuleFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return { success: false, error: result.error };
+    }
+  }
+  static async fromFileLegacy({
+    relativeFilePath,
+    validate = true
+  }) {
+    const filePath = join34(this.getSettablePaths().legacy.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+    }
+    const validatedFrontmatter = {
+      root: result.data.root ?? false,
+      targets: result.data.targets ?? ["*"],
+      description: result.data.description ?? "",
+      globs: result.data.globs ?? [],
+      cursor: result.data.cursor
+    };
+    const filename = basename14(filePath);
+    return new _RulesyncRule({
+      baseDir: ".",
+      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
+      relativeFilePath: filename,
+      frontmatter: validatedFrontmatter,
+      body: content.trim(),
+      validate
+    });
+  }
+  static async fromFile({
+    relativeFilePath,
+    validate = true
+  }) {
+    const filePath = join34(this.getSettablePaths().recommended.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${filePath}: ${result.error.message}`);
+    }
+    const validatedFrontmatter = {
+      root: result.data.root ?? false,
+      targets: result.data.targets ?? ["*"],
+      description: result.data.description ?? "",
+      globs: result.data.globs ?? [],
+      cursor: result.data.cursor
+    };
+    const filename = basename14(filePath);
+    return new _RulesyncRule({
+      baseDir: ".",
+      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
+      relativeFilePath: filename,
+      frontmatter: validatedFrontmatter,
+      body: content.trim(),
+      validate
+    });
+  }
+  getBody() {
+    return this.body;
+  }
+};
+
+// src/rules/tool-rule.ts
+var ToolRule = class extends ToolFile {
+  root;
+  constructor({ root = false, ...rest }) {
+    super(rest);
+    this.root = root;
+  }
+  static async fromFile(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static fromRulesyncRule(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static buildToolRuleParamsDefault({
+    baseDir = ".",
+    rulesyncRule,
+    validate = true,
+    rootPath = { relativeDirPath: ".", relativeFilePath: "AGENTS.md" },
+    nonRootPath = { relativeDirPath: ".agents/memories" }
+  }) {
+    const fileContent = rulesyncRule.getBody();
+    return {
+      baseDir,
+      relativeDirPath: rulesyncRule.getFrontmatter().root ? rootPath.relativeDirPath : nonRootPath.relativeDirPath,
+      relativeFilePath: rulesyncRule.getFrontmatter().root ? rootPath.relativeFilePath : rulesyncRule.getRelativeFilePath(),
+      fileContent,
+      validate,
+      root: rulesyncRule.getFrontmatter().root ?? false
+    };
+  }
+  toRulesyncRuleDefault() {
+    return new RulesyncRule({
+      baseDir: this.getBaseDir(),
+      relativeDirPath: RULESYNC_RULES_DIR,
+      relativeFilePath: this.getRelativeFilePath(),
+      frontmatter: {
+        root: this.isRoot(),
+        targets: ["*"],
+        description: "",
+        globs: this.isRoot() ? ["**/*"] : []
+      },
+      body: this.getFileContent()
+    });
+  }
+  isRoot() {
+    return this.root;
+  }
+  static isTargetedByRulesyncRule(_rulesyncRule) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static isTargetedByRulesyncRuleDefault({
+    rulesyncRule,
+    toolTarget
+  }) {
+    const targets = rulesyncRule.getFrontmatter().targets;
+    if (!targets) {
+      return true;
+    }
+    if (targets.includes("*")) {
+      return true;
+    }
+    if (targets.includes(toolTarget)) {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/rules/agentsmd-rule.ts
+var AgentsMdRule = class _AgentsMdRule extends ToolRule {
+  constructor({ fileContent, root, ...rest }) {
+    super({
+      ...rest,
+      fileContent,
+      root: root ?? false
+    });
+  }
+  static getSettablePaths() {
+    return {
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: "AGENTS.md"
+      },
+      nonRoot: {
+        relativeDirPath: ".agents/memories"
+      }
+    };
+  }
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const isRoot = relativeFilePath === "AGENTS.md";
+    const relativePath = isRoot ? "AGENTS.md" : join35(".agents/memories", relativeFilePath);
+    const fileContent = await readFileContent(join35(baseDir, relativePath));
+    return new _AgentsMdRule({
+      baseDir,
+      relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
+      relativeFilePath: isRoot ? "AGENTS.md" : relativeFilePath,
+      fileContent,
+      validate,
+      root: isRoot
+    });
+  }
+  static fromRulesyncRule({
+    baseDir = ".",
+    rulesyncRule,
+    validate = true
+  }) {
+    return new _AgentsMdRule(
+      this.buildToolRuleParamsDefault({
+        baseDir,
+        rulesyncRule,
+        validate,
+        rootPath: this.getSettablePaths().root,
+        nonRootPath: this.getSettablePaths().nonRoot
+      })
+    );
+  }
+  toRulesyncRule() {
+    return this.toRulesyncRuleDefault();
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "agentsmd"
+    });
+  }
+};
+
+// src/rules/amazonqcli-rule.ts
+import { join as join36 } from "path";
+var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
+  static getSettablePaths() {
+    return {
+      nonRoot: {
+        relativeDirPath: ".amazonq/rules"
+      }
+    };
+  }
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const fileContent = await readFileContent(
+      join36(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+    );
+    return new _AmazonQCliRule({
+      baseDir,
+      relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
+      relativeFilePath,
+      fileContent,
+      validate,
+      root: false
+    });
+  }
+  static fromRulesyncRule({
+    baseDir = ".",
+    rulesyncRule,
+    validate = true
+  }) {
+    return new _AmazonQCliRule(
+      this.buildToolRuleParamsDefault({
+        baseDir,
+        rulesyncRule,
+        validate,
+        nonRootPath: this.getSettablePaths().nonRoot
+      })
+    );
+  }
+  toRulesyncRule() {
+    return this.toRulesyncRuleDefault();
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "amazonqcli"
+    });
+  }
+};
+
+// src/rules/augmentcode-legacy-rule.ts
+import { join as join37 } from "path";
+var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
+  toRulesyncRule() {
+    const rulesyncFrontmatter = {
+      root: this.isRoot(),
+      targets: ["*"],
+      description: "",
+      globs: this.isRoot() ? ["**/*"] : []
+    };
+    return new RulesyncRule({
+      baseDir: this.getBaseDir(),
+      frontmatter: rulesyncFrontmatter,
+      body: this.getFileContent(),
+      relativeDirPath: RULESYNC_RULES_DIR,
+      relativeFilePath: this.getRelativeFilePath(),
+      validate: true
+    });
+  }
+  static getSettablePaths() {
+    return {
+      root: {
+        relativeDirPath: ".",
+        relativeFilePath: ".augment-guidelines"
+      },
+      nonRoot: {
+        relativeDirPath: ".augment/rules"
+      }
+    };
+  }
+  static fromRulesyncRule({
+    baseDir = ".",
+    rulesyncRule,
+    validate = true
+  }) {
+    return new _AugmentcodeLegacyRule(
+      this.buildToolRuleParamsDefault({
+        baseDir,
+        rulesyncRule,
+        validate,
+        rootPath: this.getSettablePaths().root,
+        nonRootPath: this.getSettablePaths().nonRoot
+      })
+    );
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "augmentcode-legacy"
+    });
+  }
+  static async fromFile({
+    baseDir = ".",
+    relativeFilePath,
+    validate = true
+  }) {
+    const settablePaths = this.getSettablePaths();
+    const isRoot = relativeFilePath === settablePaths.root.relativeFilePath;
+    const relativePath = isRoot ? settablePaths.root.relativeFilePath : join37(settablePaths.nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join37(baseDir, relativePath));
+    return new _AugmentcodeLegacyRule({
+      baseDir,
+      relativeDirPath: isRoot ? settablePaths.root.relativeDirPath : settablePaths.nonRoot.relativeDirPath,
+      relativeFilePath: isRoot ? settablePaths.root.relativeFilePath : relativeFilePath,
+      fileContent,
+      validate,
+      root: isRoot
+    });
+  }
+};
+
+// src/rules/augmentcode-rule.ts
+import { join as join38 } from "path";
+var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
+  toRulesyncRule() {
     return this.toRulesyncRuleDefault();
   }
   static getSettablePaths() {
@@ -3318,7 +3896,7 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join35(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join38(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     const { body: content } = parseFrontmatter(fileContent);
     return new _AugmentcodeRule({
@@ -3332,10 +3910,16 @@ var AugmentcodeRule = class _AugmentcodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "augmentcode"
+    });
+  }
 };
 
 // src/rules/claudecode-rule.ts
-import { join as join36 } from "path";
+import { join as join39 } from "path";
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3354,8 +3938,8 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join36(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join36(baseDir, relativePath));
+    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join39(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join39(baseDir, relativePath));
     return new _ClaudecodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3386,13 +3970,19 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "claudecode"
+    });
+  }
 };
 
 // src/rules/cline-rule.ts
-import { join as join37 } from "path";
-import { z as z15 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z15.object({
-  description: z15.string()
+import { join as join40 } from "path";
+import { z as z17 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z17.object({
+  description: z17.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -3422,13 +4012,19 @@ var ClineRule = class _ClineRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "cline"
+    });
+  }
   static async fromFile({
     baseDir = ".",
     relativeFilePath,
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join37(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join40(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _ClineRule({
       baseDir,
@@ -3441,7 +4037,7 @@ var ClineRule = class _ClineRule extends ToolRule {
 };
 
 // src/rules/codexcli-rule.ts
-import { join as join38 } from "path";
+import { join as join41 } from "path";
 var CodexcliRule = class _CodexcliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3460,8 +4056,8 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join38(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join38(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : join41(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join41(baseDir, relativePath));
     return new _CodexcliRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3492,14 +4088,20 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "codexcli"
+    });
+  }
 };
 
 // src/rules/copilot-rule.ts
-import { join as join39 } from "path";
-import { z as z16 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z16.object({
-  description: z16.optional(z16.string()),
-  applyTo: z16.optional(z16.string())
+import { join as join42 } from "path";
+import { z as z18 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z18.object({
+  description: z18.optional(z18.string()),
+  applyTo: z18.optional(z18.string())
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -3587,11 +4189,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "copilot-instructions.md";
-    const relativePath = isRoot ? join39(
+    const relativePath = isRoot ? join42(
       this.getSettablePaths().root.relativeDirPath,
       this.getSettablePaths().root.relativeFilePath
-    ) : join39(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join39(baseDir, relativePath));
+    ) : join42(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join42(baseDir, relativePath));
     if (isRoot) {
       return new _CopilotRule({
         baseDir,
@@ -3610,7 +4212,7 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(
-        `Invalid frontmatter in ${join39(baseDir, relativeFilePath)}: ${result.error.message}`
+        `Invalid frontmatter in ${join42(baseDir, relativeFilePath)}: ${result.error.message}`
       );
     }
     return new _CopilotRule({
@@ -3640,15 +4242,21 @@ var CopilotRule = class _CopilotRule extends ToolRule {
   getBody() {
     return this.body;
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "copilot"
+    });
+  }
 };
 
 // src/rules/cursor-rule.ts
-import { basename as basename13, join as join40 } from "path";
-import { z as z17 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z17.object({
-  description: z17.optional(z17.string()),
-  globs: z17.optional(z17.string()),
-  alwaysApply: z17.optional(z17.boolean())
+import { basename as basename15, join as join43 } from "path";
+import { z as z19 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z19.object({
+  description: z19.optional(z19.string()),
+  globs: z19.optional(z19.string()),
+  alwaysApply: z19.optional(z19.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -3773,19 +4381,19 @@ var CursorRule = class _CursorRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join40(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join43(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     const { frontmatter, body: content } = _CursorRule.parseCursorFrontmatter(fileContent);
     const result = CursorRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(
-        `Invalid frontmatter in ${join40(baseDir, relativeFilePath)}: ${result.error.message}`
+        `Invalid frontmatter in ${join43(baseDir, relativeFilePath)}: ${result.error.message}`
       );
     }
     return new _CursorRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: basename13(relativeFilePath),
+      relativeFilePath: basename15(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -3808,10 +4416,16 @@ var CursorRule = class _CursorRule extends ToolRule {
   getBody() {
     return this.body;
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "cursor"
+    });
+  }
 };
 
 // src/rules/geminicli-rule.ts
-import { join as join41 } from "path";
+import { join as join44 } from "path";
 var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3830,8 +4444,8 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "GEMINI.md";
-    const relativePath = isRoot ? "GEMINI.md" : join41(".gemini/memories", relativeFilePath);
-    const fileContent = await readFileContent(join41(baseDir, relativePath));
+    const relativePath = isRoot ? "GEMINI.md" : join44(".gemini/memories", relativeFilePath);
+    const fileContent = await readFileContent(join44(baseDir, relativePath));
     return new _GeminiCliRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3862,10 +4476,16 @@ var GeminiCliRule = class _GeminiCliRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "geminicli"
+    });
+  }
 };
 
 // src/rules/junie-rule.ts
-import { join as join42 } from "path";
+import { join as join45 } from "path";
 var JunieRule = class _JunieRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3884,8 +4504,8 @@ var JunieRule = class _JunieRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "guidelines.md";
-    const relativePath = isRoot ? "guidelines.md" : join42(".junie/memories", relativeFilePath);
-    const fileContent = await readFileContent(join42(baseDir, relativePath));
+    const relativePath = isRoot ? "guidelines.md" : join45(".junie/memories", relativeFilePath);
+    const fileContent = await readFileContent(join45(baseDir, relativePath));
     return new _JunieRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -3916,10 +4536,16 @@ var JunieRule = class _JunieRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "junie"
+    });
+  }
 };
 
 // src/rules/kiro-rule.ts
-import { join as join43 } from "path";
+import { join as join46 } from "path";
 var KiroRule = class _KiroRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3934,7 +4560,7 @@ var KiroRule = class _KiroRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join43(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join46(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _KiroRule({
       baseDir,
@@ -3965,10 +4591,16 @@ var KiroRule = class _KiroRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "kiro"
+    });
+  }
 };
 
 // src/rules/opencode-rule.ts
-import { join as join44 } from "path";
+import { join as join47 } from "path";
 var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -3987,8 +4619,8 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "AGENTS.md";
-    const relativePath = isRoot ? "AGENTS.md" : join44(".opencode/memories", relativeFilePath);
-    const fileContent = await readFileContent(join44(baseDir, relativePath));
+    const relativePath = isRoot ? "AGENTS.md" : join47(".opencode/memories", relativeFilePath);
+    const fileContent = await readFileContent(join47(baseDir, relativePath));
     return new _OpenCodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4019,10 +4651,16 @@ var OpenCodeRule = class _OpenCodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "opencode"
+    });
+  }
 };
 
 // src/rules/qwencode-rule.ts
-import { join as join45 } from "path";
+import { join as join48 } from "path";
 var QwencodeRule = class _QwencodeRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4041,8 +4679,8 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === "QWEN.md";
-    const relativePath = isRoot ? "QWEN.md" : join45(".qwen/memories", relativeFilePath);
-    const fileContent = await readFileContent(join45(baseDir, relativePath));
+    const relativePath = isRoot ? "QWEN.md" : join48(".qwen/memories", relativeFilePath);
+    const fileContent = await readFileContent(join48(baseDir, relativePath));
     return new _QwencodeRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : this.getSettablePaths().nonRoot.relativeDirPath,
@@ -4070,10 +4708,16 @@ var QwencodeRule = class _QwencodeRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "qwencode"
+    });
+  }
 };
 
 // src/rules/roo-rule.ts
-import { join as join46 } from "path";
+import { join as join49 } from "path";
 var RooRule = class _RooRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4088,7 +4732,7 @@ var RooRule = class _RooRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join46(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join49(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _RooRule({
       baseDir,
@@ -4134,10 +4778,16 @@ var RooRule = class _RooRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "roo"
+    });
+  }
 };
 
 // src/rules/warp-rule.ts
-import { join as join47 } from "path";
+import { join as join50 } from "path";
 var WarpRule = class _WarpRule extends ToolRule {
   constructor({ fileContent, root, ...rest }) {
     super({
@@ -4163,8 +4813,8 @@ var WarpRule = class _WarpRule extends ToolRule {
     validate = true
   }) {
     const isRoot = relativeFilePath === this.getSettablePaths().root.relativeFilePath;
-    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join47(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent(join47(baseDir, relativePath));
+    const relativePath = isRoot ? this.getSettablePaths().root.relativeFilePath : join50(this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(join50(baseDir, relativePath));
     return new _WarpRule({
       baseDir,
       relativeDirPath: isRoot ? this.getSettablePaths().root.relativeDirPath : ".warp",
@@ -4195,10 +4845,16 @@ var WarpRule = class _WarpRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "warp"
+    });
+  }
 };
 
 // src/rules/windsurf-rule.ts
-import { join as join48 } from "path";
+import { join as join51 } from "path";
 var WindsurfRule = class _WindsurfRule extends ToolRule {
   static getSettablePaths() {
     return {
@@ -4213,7 +4869,7 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
     validate = true
   }) {
     const fileContent = await readFileContent(
-      join48(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+      join51(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
     );
     return new _WindsurfRule({
       baseDir,
@@ -4243,6 +4899,12 @@ var WindsurfRule = class _WindsurfRule extends ToolRule {
   validate() {
     return { success: true, error: null };
   }
+  static isTargetedByRulesyncRule(rulesyncRule) {
+    return this.isTargetedByRulesyncRuleDefault({
+      rulesyncRule,
+      toolTarget: "windsurf"
+    });
+  }
 };
 
 // src/rules/rules-processor.ts
@@ -4265,7 +4927,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z18.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z20.enum(rulesProcessorToolTargets);
 var RulesProcessor = class extends FeatureProcessor {
   toolTarget;
   simulateCommands;
@@ -4288,102 +4950,153 @@ var RulesProcessor = class extends FeatureProcessor {
     const toolRules = rulesyncRules.map((rulesyncRule) => {
       switch (this.toolTarget) {
         case "agentsmd":
+          if (!AgentsMdRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AgentsMdRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "amazonqcli":
+          if (!AmazonQCliRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AmazonQCliRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "augmentcode":
+          if (!AugmentcodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AugmentcodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "augmentcode-legacy":
+          if (!AugmentcodeLegacyRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return AugmentcodeLegacyRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "claudecode":
+          if (!ClaudecodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return ClaudecodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "cline":
+          if (!ClineRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return ClineRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "codexcli":
+          if (!CodexcliRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return CodexcliRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "copilot":
+          if (!CopilotRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return CopilotRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "cursor":
+          if (!CursorRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return CursorRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "geminicli":
+          if (!GeminiCliRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return GeminiCliRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "junie":
+          if (!JunieRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return JunieRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "kiro":
+          if (!KiroRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return KiroRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "opencode":
+          if (!OpenCodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return OpenCodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "qwencode":
+          if (!QwencodeRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return QwencodeRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "roo":
+          if (!RooRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return RooRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "warp":
+          if (!WarpRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return WarpRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
             validate: true
           });
         case "windsurf":
+          if (!WindsurfRule.isTargetedByRulesyncRule(rulesyncRule)) {
+            return null;
+          }
           return WindsurfRule.fromRulesyncRule({
             baseDir: this.baseDir,
             rulesyncRule,
@@ -4392,8 +5105,9 @@ var RulesProcessor = class extends FeatureProcessor {
         default:
           throw new Error(`Unsupported tool target: ${this.toolTarget}`);
       }
-    });
-    if (this.toolTarget === "cursor" && (this.simulateCommands || this.simulateSubagents)) {
+    }).filter((rule) => rule !== null);
+    const isSimulated = this.simulateCommands || this.simulateSubagents;
+    if (isSimulated && this.toolTarget === "cursor") {
       toolRules.push(
         new CursorRule({
           baseDir: this.baseDir,
@@ -4412,6 +5126,22 @@ var RulesProcessor = class extends FeatureProcessor {
         })
       );
     }
+    if (isSimulated && this.toolTarget === "roo") {
+      toolRules.push(
+        new RooRule({
+          baseDir: this.baseDir,
+          relativeDirPath: RooRule.getSettablePaths().nonRoot.relativeDirPath,
+          relativeFilePath: "additional-conventions.md",
+          fileContent: this.generateAdditionalConventionsSection({
+            commands: { relativeDirPath: RooCommand.getSettablePaths().relativeDirPath },
+            subagents: {
+              relativeDirPath: RooSubagent.getSettablePaths().relativeDirPath
+            }
+          }),
+          validate: true
+        })
+      );
+    }
     const rootRuleIndex = toolRules.findIndex((rule) => rule.isRoot());
     if (rootRuleIndex === -1) {
       return toolRules;
@@ -4465,7 +5195,12 @@ var RulesProcessor = class extends FeatureProcessor {
       case "geminicli": {
         const rootRule = toolRules[rootRuleIndex];
         rootRule?.setFileContent(
-          this.generateXmlReferencesSection(toolRules) + rootRule.getFileContent()
+          this.generateXmlReferencesSection(toolRules) + this.generateAdditionalConventionsSection({
+            commands: { relativeDirPath: GeminiCliCommand.getSettablePaths().relativeDirPath },
+            subagents: {
+              relativeDirPath: GeminiCliSubagent.getSettablePaths().relativeDirPath
+            }
+          }) + rootRule.getFileContent()
         );
         return toolRules;
       }
@@ -4513,17 +5248,17 @@ var RulesProcessor = class extends FeatureProcessor {
    * Load and parse rulesync rule files from .rulesync/rules/ directory
    */
   async loadRulesyncFiles() {
-    const files = await findFilesByGlobs(join49(RULESYNC_RULES_DIR, "*.md"));
+    const files = await findFilesByGlobs(join52(RULESYNC_RULES_DIR, "*.md"));
     logger.debug(`Found ${files.length} rulesync files`);
     return Promise.all(
-      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename14(file) }))
+      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename16(file) }))
     );
   }
   async loadRulesyncFilesLegacy() {
-    const legacyFiles = await findFilesByGlobs(join49(RULESYNC_RULES_DIR_LEGACY, "*.md"));
+    const legacyFiles = await findFilesByGlobs(join52(RULESYNC_RULES_DIR_LEGACY, "*.md"));
     logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
     return Promise.all(
-      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename14(file) }))
+      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename16(file) }))
     );
   }
   /**
@@ -4575,794 +5310,414 @@ var RulesProcessor = class extends FeatureProcessor {
       return [];
     }
   }
-  async loadToolRulesDefault({
-    root,
-    nonRoot
-  }) {
-    const rootToolRules = await (async () => {
-      if (!root) {
-        return [];
-      }
-      const rootFilePaths = await findFilesByGlobs(
-        join49(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
-      );
-      return await Promise.all(
-        rootFilePaths.map(
-          (filePath) => root.fromFile({
-            baseDir: this.baseDir,
-            relativeFilePath: basename14(filePath)
-          })
-        )
-      );
-    })();
-    logger.debug(`Found ${rootToolRules.length} root tool rule files`);
-    const nonRootToolRules = await (async () => {
-      if (!nonRoot) {
-        return [];
-      }
-      const nonRootFilePaths = await findFilesByGlobs(
-        join49(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
-      );
-      return await Promise.all(
-        nonRootFilePaths.map(
-          (filePath) => nonRoot.fromFile({
-            baseDir: this.baseDir,
-            relativeFilePath: basename14(filePath)
-          })
-        )
-      );
-    })();
-    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"
+  async loadToolRulesDefault({
+    root,
+    nonRoot
+  }) {
+    const rootToolRules = await (async () => {
+      if (!root) {
+        return [];
       }
-    });
+      const rootFilePaths = await findFilesByGlobs(
+        join52(this.baseDir, root.relativeDirPath ?? ".", root.relativeFilePath)
+      );
+      return await Promise.all(
+        rootFilePaths.map(
+          (filePath) => root.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: basename16(filePath)
+          })
+        )
+      );
+    })();
+    logger.debug(`Found ${rootToolRules.length} root tool rule files`);
+    const nonRootToolRules = await (async () => {
+      if (!nonRoot) {
+        return [];
+      }
+      const nonRootFilePaths = await findFilesByGlobs(
+        join52(this.baseDir, nonRoot.relativeDirPath, `*.${nonRoot.extension}`)
+      );
+      return await Promise.all(
+        nonRootFilePaths.map(
+          (filePath) => nonRoot.fromFile({
+            baseDir: this.baseDir,
+            relativeFilePath: basename16(filePath)
+          })
+        )
+      );
+    })();
+    logger.debug(`Found ${nonRootToolRules.length} non-root tool rule files`);
+    return [...rootToolRules, ...nonRootToolRules];
   }
   /**
-   * Load OpenCode rule configuration from AGENTS.md file and .opencode/memories/*.md files
+   * Load AGENTS.md rule configuration
    */
-  async loadOpencodeRules() {
-    const settablePaths = OpenCodeRule.getSettablePaths();
+  async loadAgentsmdRules() {
+    const settablePaths = AgentsMdRule.getSettablePaths();
     return await this.loadToolRulesDefault({
       root: {
         relativeDirPath: settablePaths.root.relativeDirPath,
         relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => OpenCodeRule.fromFile(params)
+        fromFile: (params) => AgentsMdRule.fromFile(params)
       },
       nonRoot: {
         relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => OpenCodeRule.fromFile(params),
+        fromFile: (params) => AgentsMdRule.fromFile(params),
         extension: "md"
       }
     });
   }
-  /**
-   * Load Qwen Code rule configuration from QWEN.md file and .qwen/memories/*.md files
-   */
-  async loadQwencodeRules() {
-    const settablePaths = QwencodeRule.getSettablePaths();
+  async loadWarpRules() {
+    const settablePaths = WarpRule.getSettablePaths();
     return await this.loadToolRulesDefault({
       root: {
         relativeDirPath: settablePaths.root.relativeDirPath,
         relativeFilePath: settablePaths.root.relativeFilePath,
-        fromFile: (params) => QwencodeRule.fromFile(params)
+        fromFile: (params) => WarpRule.fromFile(params)
       },
       nonRoot: {
         relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => QwencodeRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Roo Code rule configurations from .roo/rules/ directory
-   */
-  async loadRooRules() {
-    const settablePaths = RooRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => RooRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Load Windsurf rule configurations from .windsurf/rules/ directory
-   */
-  async loadWindsurfRules() {
-    const settablePaths = WindsurfRule.getSettablePaths();
-    return await this.loadToolRulesDefault({
-      nonRoot: {
-        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
-        fromFile: (params) => WindsurfRule.fromFile(params),
-        extension: "md"
-      }
-    });
-  }
-  /**
-   * Implementation of abstract method from FeatureProcessor
-   * Return the tool targets that this processor supports
-   */
-  static getToolTargets() {
-    return rulesProcessorToolTargets;
-  }
-  generateXmlReferencesSection(toolRules) {
-    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
-    if (toolRulesWithoutRoot.length === 0) {
-      return "";
-    }
-    const lines = [];
-    lines.push(
-      "Please also reference the following documents as needed. In this case, `@` stands for the project root directory."
-    );
-    lines.push("");
-    const documentsData = {
-      Documents: {
-        Document: toolRulesWithoutRoot.map((rule) => {
-          const rulesyncRule = rule.toRulesyncRule();
-          const frontmatter = rulesyncRule.getFrontmatter();
-          const relativePath = `@${rule.getRelativePathFromCwd()}`;
-          const document = {
-            Path: relativePath
-          };
-          if (frontmatter.description) {
-            document.Description = frontmatter.description;
-          }
-          if (frontmatter.globs && frontmatter.globs.length > 0) {
-            document.FilePatterns = frontmatter.globs.join(", ");
-          }
-          return document;
-        })
-      }
-    };
-    const builder = new XMLBuilder({
-      format: true,
-      ignoreAttributes: false,
-      suppressEmptyNode: false
-    });
-    const xmlContent = builder.build(documentsData);
-    lines.push(xmlContent);
-    return lines.join("\n") + "\n";
-  }
-  generateReferencesSection(toolRules) {
-    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
-    if (toolRulesWithoutRoot.length === 0) {
-      return "";
-    }
-    const lines = [];
-    lines.push("Please also reference the following documents as needed:");
-    lines.push("");
-    for (const rule of toolRulesWithoutRoot) {
-      const rulesyncRule = rule.toRulesyncRule();
-      const frontmatter = rulesyncRule.getFrontmatter();
-      const escapedDescription = frontmatter.description?.replace(/"/g, '\\"');
-      const globsText = frontmatter.globs?.join(",");
-      lines.push(
-        `@${rule.getRelativePathFromCwd()} description: "${escapedDescription}" globs: "${globsText}"`
-      );
-    }
-    return lines.join("\n") + "\n";
-  }
-  generateAdditionalConventionsSection({
-    commands,
-    subagents
-  }) {
-    return `# Additional Conventions Beyond the Built-in Functions
-
-As this project's AI coding tool, you must follow the additional conventions below, in addition to the built-in functions.
-
-${this.simulateCommands ? `## Simulated Custom Slash Commands
-
-Custom slash commands allow you to define frequently-used prompts as Markdown files that you can execute.
-
-### Syntax
-
-Users can use following syntax to invoke a custom command.
-
-\`\`\`txt
-s/<command> [arguments]
-\`\`\`
-
-This syntax employs a double slash (\`s/\`) to prevent conflicts with built-in slash commands.  
-The \`s\` in \`s/\` stands for *simulate*. Because custom slash commands are not built-in, this syntax provides a pseudo way to invoke them.
-
-When users call a custom slash command, you have to look for the markdown file, \`${join49(commands.relativeDirPath, "{command}.md")}\`, then execute the contents of that file as the block of operations.` : ""}
-
-${this.simulateSubagents ? `## Simulated Subagents
-
-Simulated subagents are specialized AI assistants that can be invoked to handle specific types of tasks. In this case, it can be appear something like simulated custom slash commands simply. Simulated subagents can be called by simulated custom slash commands.
-
-When users call a simulated subagent, it will look for the corresponding markdown file, \`${join49(subagents.relativeDirPath, "{subagent}.md")}\`, and execute its contents as the block of operations.` : ""}`.trim();
-  }
-};
-
-// src/subagents/subagents-processor.ts
-import { basename as basename16, join as join52 } from "path";
-import { z as z21 } from "zod/mini";
-
-// src/subagents/claudecode-subagent.ts
-import { join as join51 } from "path";
-import { z as z20 } from "zod/mini";
-
-// src/subagents/rulesync-subagent.ts
-import { basename as basename15, join as join50 } from "path";
-import { z as z19 } from "zod/mini";
-var RulesyncSubagentModelSchema = z19.enum(["opus", "sonnet", "haiku", "inherit"]);
-var RulesyncSubagentFrontmatterSchema = z19.object({
-  targets: RulesyncTargetsSchema,
-  name: z19.string(),
-  description: z19.string(),
-  claudecode: z19.optional(
-    z19.object({
-      model: RulesyncSubagentModelSchema
-    })
-  )
-});
-var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
-  frontmatter;
-  body;
-  constructor({ frontmatter, body, ...rest }) {
-    if (rest.validate !== false) {
-      const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
-      if (!result.success) {
-        throw result.error;
-      }
-    }
-    super({
-      ...rest
-    });
-    this.frontmatter = frontmatter;
-    this.body = body;
-  }
-  static getSettablePaths() {
-    return {
-      relativeDirPath: ".rulesync/subagents"
-    };
-  }
-  getFrontmatter() {
-    return this.frontmatter;
-  }
-  getBody() {
-    return this.body;
-  }
-  validate() {
-    if (!this.frontmatter) {
-      return { success: true, error: null };
-    }
-    const result = RulesyncSubagentFrontmatterSchema.safeParse(this.frontmatter);
-    if (result.success) {
-      return { success: true, error: null };
-    } else {
-      return { success: false, error: result.error };
-    }
-  }
-  static async fromFile({
-    relativeFilePath
-  }) {
-    const fileContent = await readFileContent(join50(RULESYNC_SUBAGENTS_DIR, relativeFilePath));
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
-    }
-    const filename = basename15(relativeFilePath);
-    return new _RulesyncSubagent({
-      baseDir: ".",
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: filename,
-      frontmatter: result.data,
-      body: content.trim(),
-      fileContent
-    });
-  }
-};
-
-// src/subagents/claudecode-subagent.ts
-var ClaudecodeSubagentFrontmatterSchema = z20.object({
-  name: z20.string(),
-  description: z20.string(),
-  model: z20.optional(z20.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;
+        fromFile: (params) => WarpRule.fromFile(params),
+        extension: "md"
       }
-    }
-    super({
-      ...rest
     });
-    this.frontmatter = frontmatter;
-    this.body = body;
-  }
-  static getSettablePaths() {
-    return {
-      relativeDirPath: ".claude/agents"
-    };
   }
-  getFrontmatter() {
-    return this.frontmatter;
-  }
-  getBody() {
-    return this.body;
+  /**
+   * 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"
+      }
+    });
   }
-  toRulesyncSubagent() {
-    const rulesyncFrontmatter = {
-      targets: ["claudecode"],
-      name: this.frontmatter.name,
-      description: this.frontmatter.description,
-      ...this.frontmatter.model && {
-        claudecode: {
-          model: this.frontmatter.model
-        }
+  /**
+   * 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"
       }
-    };
-    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 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"
+      }
     });
   }
-  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 Claude Code rule configuration from CLAUDE.md file
+   */
+  async loadClaudecodeRules() {
+    const settablePaths = ClaudecodeRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => ClaudecodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => ClaudecodeRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
-  static async fromFile({
-    baseDir = ".",
-    relativeFilePath,
-    validate = true
-  }) {
-    const fileContent = await readFileContent(join51(baseDir, ".claude/agents", relativeFilePath));
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${result.error.message}`);
-    }
-    return new _ClaudecodeSubagent({
-      baseDir,
-      relativeDirPath: ".claude/agents",
-      relativeFilePath,
-      frontmatter: result.data,
-      body: content.trim(),
-      fileContent,
-      validate
+  /**
+   * Load Cline rule configurations from .clinerules/ directory
+   */
+  async loadClineRules() {
+    const settablePaths = ClineRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => ClineRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
-};
-
-// src/subagents/subagents-processor.ts
-var subagentsProcessorToolTargets = [
-  "claudecode",
-  "copilot",
-  "cursor",
-  "codexcli"
-];
-var subagentsProcessorToolTargetsSimulated = [
-  "copilot",
-  "cursor",
-  "codexcli"
-];
-var SubagentsProcessorToolTargetSchema = z21.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":
-          return ClaudecodeSubagent.fromRulesyncSubagent({
-            baseDir: this.baseDir,
-            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
-            rulesyncSubagent
-          });
-        case "copilot":
-          return CopilotSubagent.fromRulesyncSubagent({
-            baseDir: this.baseDir,
-            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
-            rulesyncSubagent
-          });
-        case "cursor":
-          return CursorSubagent.fromRulesyncSubagent({
-            baseDir: this.baseDir,
-            relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
-            rulesyncSubagent
-          });
-        case "codexcli":
-          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"
       }
     });
-    return toolSubagents;
   }
-  async convertToolFilesToRulesyncFiles(toolFiles) {
-    const toolSubagents = toolFiles.filter(
-      (file) => file instanceof ToolSubagent
-    );
-    const rulesyncSubagents = [];
-    for (const toolSubagent of toolSubagents) {
-      if (toolSubagent instanceof SimulatedSubagent) {
-        logger.debug(
-          `Skipping simulated subagent conversion: ${toolSubagent.getRelativeFilePath()}`
-        );
-        continue;
+  /**
+   * Load Cursor rule configurations from .cursor/rules/ directory
+   */
+  async loadCursorRules() {
+    const settablePaths = CursorRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => CursorRule.fromFile(params),
+        extension: "mdc"
       }
-      rulesyncSubagents.push(toolSubagent.toRulesyncSubagent());
-    }
-    return rulesyncSubagents;
+    });
   }
   /**
-   * Implementation of abstract method from Processor
-   * Load and parse rulesync subagent files from .rulesync/subagents/ directory
+   * Load Gemini CLI rule configuration from GEMINI.md file
    */
-  async loadRulesyncFiles() {
-    const subagentsDir = join52(this.baseDir, RulesyncSubagent.getSettablePaths().relativeDirPath);
-    const dirExists = await directoryExists(subagentsDir);
-    if (!dirExists) {
-      logger.debug(`Rulesync subagents directory not found: ${subagentsDir}`);
-      return [];
-    }
-    const entries = await listDirectoryFiles(subagentsDir);
-    const mdFiles = entries.filter((file) => file.endsWith(".md"));
-    if (mdFiles.length === 0) {
-      logger.debug(`No markdown files found in rulesync subagents directory: ${subagentsDir}`);
-      return [];
-    }
-    logger.info(`Found ${mdFiles.length} subagent files in ${subagentsDir}`);
-    const rulesyncSubagents = [];
-    for (const mdFile of mdFiles) {
-      const filepath = join52(subagentsDir, mdFile);
-      try {
-        const rulesyncSubagent = await RulesyncSubagent.fromFile({
-          relativeFilePath: mdFile,
-          validate: true
-        });
-        rulesyncSubagents.push(rulesyncSubagent);
-        logger.debug(`Successfully loaded subagent: ${mdFile}`);
-      } catch (error) {
-        logger.warn(`Failed to load subagent file ${filepath}:`, error);
-        continue;
+  async loadGeminicliRules() {
+    const settablePaths = GeminiCliRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => GeminiCliRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => GeminiCliRule.fromFile(params),
+        extension: "md"
       }
-    }
-    if (rulesyncSubagents.length === 0) {
-      logger.debug(`No valid subagents found in ${subagentsDir}`);
-      return [];
-    }
-    logger.info(`Successfully loaded ${rulesyncSubagents.length} rulesync subagents`);
-    return rulesyncSubagents;
+    });
   }
   /**
-   * Implementation of abstract method from Processor
-   * Load tool-specific subagent configurations and parse them into ToolSubagent instances
+   * Load JetBrains Junie rule configuration from .junie/guidelines.md file
    */
-  async loadToolFiles() {
-    switch (this.toolTarget) {
-      case "claudecode":
-        return await this.loadClaudecodeSubagents();
-      case "copilot":
-        return await this.loadCopilotSubagents();
-      case "cursor":
-        return await this.loadCursorSubagents();
-      case "codexcli":
-        return await this.loadCodexCliSubagents();
-      default:
-        throw new Error(`Unsupported tool target: ${this.toolTarget}`);
-    }
+  async loadJunieRules() {
+    const settablePaths = JunieRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => JunieRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => JunieRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
-   * Load Claude Code subagent configurations from .claude/agents/ directory
+   * Load Kiro rule configurations from .kiro/steering/ directory
    */
-  async loadClaudecodeSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: ClaudecodeSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => ClaudecodeSubagent.fromFile({ relativeFilePath })
+  async loadKiroRules() {
+    const settablePaths = KiroRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => KiroRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
   /**
-   * Load Copilot subagent configurations from .copilot/subagents/ directory
+   * Load OpenCode rule configuration from AGENTS.md file and .opencode/memories/*.md files
    */
-  async loadCopilotSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: CopilotSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => CopilotSubagent.fromFile({ relativeFilePath })
+  async loadOpencodeRules() {
+    const settablePaths = OpenCodeRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => OpenCodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => OpenCodeRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
   /**
-   * Load Cursor subagent configurations from .cursor/subagents/ directory
+   * Load Qwen Code rule configuration from QWEN.md file and .qwen/memories/*.md files
    */
-  async loadCursorSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: CursorSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => CursorSubagent.fromFile({ relativeFilePath })
+  async loadQwencodeRules() {
+    const settablePaths = QwencodeRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      root: {
+        relativeDirPath: settablePaths.root.relativeDirPath,
+        relativeFilePath: settablePaths.root.relativeFilePath,
+        fromFile: (params) => QwencodeRule.fromFile(params)
+      },
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => QwencodeRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
   /**
-   * Load CodexCli subagent configurations from .codex/subagents/ directory
+   * Load Roo Code rule configurations from .roo/rules/ directory
    */
-  async loadCodexCliSubagents() {
-    return await this.loadToolSubagentsDefault({
-      relativeDirPath: CodexCliSubagent.getSettablePaths().relativeDirPath,
-      fromFile: (relativeFilePath) => CodexCliSubagent.fromFile({ relativeFilePath })
+  async loadRooRules() {
+    const settablePaths = RooRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => RooRule.fromFile(params),
+        extension: "md"
+      }
     });
   }
-  async loadToolSubagentsDefault({
-    relativeDirPath,
-    fromFile
-  }) {
-    const paths = await findFilesByGlobs(join52(this.baseDir, relativeDirPath, "*.md"));
-    const subagents = (await Promise.allSettled(paths.map((path2) => fromFile(basename16(path2))))).filter((r) => r.status === "fulfilled").map((r) => r.value);
-    logger.info(`Successfully loaded ${subagents.length} ${relativeDirPath} subagents`);
-    return subagents;
+  /**
+   * Load Windsurf rule configurations from .windsurf/rules/ directory
+   */
+  async loadWindsurfRules() {
+    const settablePaths = WindsurfRule.getSettablePaths();
+    return await this.loadToolRulesDefault({
+      nonRoot: {
+        relativeDirPath: settablePaths.nonRoot.relativeDirPath,
+        fromFile: (params) => WindsurfRule.fromFile(params),
+        extension: "md"
+      }
+    });
   }
   /**
    * Implementation of abstract method from FeatureProcessor
    * Return the tool targets that this processor supports
    */
-  static getToolTargets({
-    includeSimulated = false
-  } = {}) {
-    if (!includeSimulated) {
-      return subagentsProcessorToolTargets.filter(
-        (target) => !subagentsProcessorToolTargetsSimulated.includes(target)
+  static getToolTargets() {
+    return rulesProcessorToolTargets;
+  }
+  generateXmlReferencesSection(toolRules) {
+    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
+    if (toolRulesWithoutRoot.length === 0) {
+      return "";
+    }
+    const lines = [];
+    lines.push(
+      "Please also reference the following documents as needed. In this case, `@` stands for the project root directory."
+    );
+    lines.push("");
+    const documentsData = {
+      Documents: {
+        Document: toolRulesWithoutRoot.map((rule) => {
+          const rulesyncRule = rule.toRulesyncRule();
+          const frontmatter = rulesyncRule.getFrontmatter();
+          const relativePath = `@${rule.getRelativePathFromCwd()}`;
+          const document = {
+            Path: relativePath
+          };
+          if (frontmatter.description) {
+            document.Description = frontmatter.description;
+          }
+          if (frontmatter.globs && frontmatter.globs.length > 0) {
+            document.FilePatterns = frontmatter.globs.join(", ");
+          }
+          return document;
+        })
+      }
+    };
+    const builder = new XMLBuilder({
+      format: true,
+      ignoreAttributes: false,
+      suppressEmptyNode: false
+    });
+    const xmlContent = builder.build(documentsData);
+    lines.push(xmlContent);
+    return lines.join("\n") + "\n";
+  }
+  generateReferencesSection(toolRules) {
+    const toolRulesWithoutRoot = toolRules.filter((rule) => !rule.isRoot());
+    if (toolRulesWithoutRoot.length === 0) {
+      return "";
+    }
+    const lines = [];
+    lines.push("Please also reference the following documents as needed:");
+    lines.push("");
+    for (const rule of toolRulesWithoutRoot) {
+      const rulesyncRule = rule.toRulesyncRule();
+      const frontmatter = rulesyncRule.getFrontmatter();
+      const escapedDescription = frontmatter.description?.replace(/"/g, '\\"');
+      const globsText = frontmatter.globs?.join(",");
+      lines.push(
+        `@${rule.getRelativePathFromCwd()} description: "${escapedDescription}" globs: "${globsText}"`
       );
     }
-    return subagentsProcessorToolTargets;
+    return lines.join("\n") + "\n";
+  }
+  generateAdditionalConventionsSection({
+    commands,
+    subagents
+  }) {
+    const overview = `# Additional Conventions Beyond the Built-in Functions
+
+As this project's AI coding tool, you must follow the additional conventions below, in addition to the built-in functions.`;
+    const commandsSection = `## Simulated Custom Slash Commands
+
+Custom slash commands allow you to define frequently-used prompts as Markdown files that you can execute.
+
+### Syntax
+
+Users can use following syntax to invoke a custom command.
+
+\`\`\`txt
+s/<command> [arguments]
+\`\`\`
+
+This syntax employs a double slash (\`s/\`) to prevent conflicts with built-in slash commands.  
+The \`s\` in \`s/\` stands for *simulate*. Because custom slash commands are not built-in, this syntax provides a pseudo way to invoke them.
+
+When users call a custom slash command, you have to look for the markdown file, \`${join52(commands.relativeDirPath, "{command}.md")}\`, then execute the contents of that file as the block of operations.`;
+    const subagentsSection = `## Simulated Subagents
+
+Simulated subagents are specialized AI assistants that can be invoked to handle specific types of tasks. In this case, it can be appear something like custom slash commands simply. Simulated subagents can be called by custom slash commands.
+
+When users call a simulated subagent, it will look for the corresponding markdown file, \`${join52(subagents.relativeDirPath, "{subagent}.md")}\`, and execute its contents as the block of operations.
+
+For example, if the user instructs \`Call planner subagent to plan the refactoring\`, you have to look for the markdown file, \`${join52(subagents.relativeDirPath, "planner.md")}\`, and execute its contents as the block of operations.`;
+    const result = [
+      overview,
+      ...this.simulateCommands && CommandsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [commandsSection] : [],
+      ...this.simulateSubagents && SubagentsProcessor.getToolTargetsSimulated().includes(this.toolTarget) ? [subagentsSection] : []
+    ].join("\n\n");
+    return result;
   }
 };
 
@@ -5535,7 +5890,7 @@ async function generateCommand(options) {
     const parts = [];
     if (totalRulesOutputs > 0) parts.push(`${totalRulesOutputs} rules`);
     if (totalIgnoreOutputs > 0) parts.push(`${totalIgnoreOutputs} ignore files`);
-    if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCPs`);
+    if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP files`);
     if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
     if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
     logger.success(`\u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`);
@@ -5567,6 +5922,7 @@ var gitignoreCommand = async () => {
     "**/GEMINI.md",
     "**/.gemini/memories/",
     "**/.gemini/commands/",
+    "**/.gemini/subagents/",
     "**/QWEN.md",
     "**/.qwen/memories/",
     "**/.aiexclude",
@@ -5584,6 +5940,7 @@ var gitignoreCommand = async () => {
     "**/.cursor/mcp.json",
     "**/.cline/mcp.json",
     "**/.roo/mcp.json",
+    "**/.roo/subagents/",
     "**/.vscode/mcp.json",
     "**/.github/commands/",
     "**/.github/subagents/",
@@ -5608,8 +5965,8 @@ var gitignoreCommand = async () => {
   }
   const newContent = gitignoreContent ? `${gitignoreContent.trimEnd()}
 
-${linesToAdd.join("")}
-` : `${linesToAdd.join("")}
+${linesToAdd.join("\n")}
+` : `${linesToAdd.join("\n")}
 `;
   await writeFileContent(gitignorePath, newContent);
   logger.success(`Added ${linesToAdd.length} rules to .gitignore:`);
@@ -5805,7 +6162,7 @@ var getVersion = async () => {
     const packageJson = await readJsonFile(packageJsonPath);
     return packageJson.version;
   } catch {
-    return "0.74.0";
+    return "0.76.0";
   }
 };
 var main = async () => {
@@ -5827,7 +6184,7 @@ var main = async () => {
     }
   ).option(
     "-f, --features <features>",
-    `Comma-separated list of features to import (${FEATURE_TYPES.join(",")}) or '*' for all`,
+    `Comma-separated list of features to import (${ALL_FEATURES.join(",")}) or '*' for all`,
     (value) => {
       return value.split(",").map((f) => f.trim());
     }
@@ -5852,7 +6209,7 @@ var main = async () => {
     }
   ).option(
     "-f, --features <features>",
-    `Comma-separated list of features to generate (${FEATURE_TYPES.join(",")}) or '*' for all`,
+    `Comma-separated list of features to generate (${ALL_FEATURES.join(",")}) or '*' for all`,
     (value) => {
       return value.split(",").map((f) => f.trim());
     }