rulesync 6.1.1 → 6.2.0

package/dist/index.js

@@ -5324,7 +5324,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 import { encode } from "@toon-format/toon";
 import { basename as basename22, join as join96, relative as relative4 } from "path";
-import { z as z44 } from "zod/mini";
+import { z as z45 } from "zod/mini";
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -7955,39 +7955,12 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
   }
 };
 
-// src/features/subagents/cursor-subagent.ts
-import { join as join65 } from "path";
-var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
-  static getSettablePaths() {
-    return {
-      relativeDirPath: join65(".cursor", "subagents")
-    };
-  }
-  static async fromFile(params) {
-    const baseParams = await this.fromFileDefault(params);
-    return new _CursorSubagent(baseParams);
-  }
-  static fromRulesyncSubagent(params) {
-    const baseParams = this.fromRulesyncSubagentDefault(params);
-    return new _CursorSubagent(baseParams);
-  }
-  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
-    return this.isTargetedByRulesyncSubagentDefault({
-      rulesyncSubagent,
-      toolTarget: "cursor"
-    });
-  }
-  static forDeletion(params) {
-    return new _CursorSubagent(this.forDeletionDefault(params));
-  }
-};
-
 // src/features/subagents/geminicli-subagent.ts
-import { join as join66 } from "path";
+import { join as join65 } from "path";
 var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join66(".gemini", "subagents")
+      relativeDirPath: join65(".gemini", "subagents")
     };
   }
   static async fromFile(params) {
@@ -8010,11 +7983,11 @@ var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/roo-subagent.ts
-import { join as join67 } from "path";
+import { join as join66 } from "path";
 var RooSubagent = class _RooSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: join67(".roo", "subagents")
+      relativeDirPath: join66(".roo", "subagents")
     };
   }
   static async fromFile(params) {
@@ -8038,14 +8011,14 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 import { basename as basename21, join as join73 } from "path";
-import { z as z37 } from "zod/mini";
+import { z as z38 } from "zod/mini";
 
 // src/features/subagents/claudecode-subagent.ts
-import { join as join69 } from "path";
+import { join as join68 } from "path";
 import { z as z33 } from "zod/mini";
 
 // src/features/subagents/rulesync-subagent.ts
-import { basename as basename19, join as join68 } from "path";
+import { basename as basename19, join as join67 } from "path";
 import { z as z32 } from "zod/mini";
 var RulesyncSubagentFrontmatterSchema = z32.looseObject({
   targets: RulesyncTargetsSchema,
@@ -8060,7 +8033,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join68(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join67(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -8093,7 +8066,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join68(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join67(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -8102,7 +8075,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
     relativeFilePath
   }) {
     const fileContent = await readFileContent(
-      join68(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
+      join67(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
     );
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -8137,7 +8110,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join69(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join68(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -8149,7 +8122,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: join69(".claude", "agents")
+      relativeDirPath: join68(".claude", "agents")
     };
   }
   getFrontmatter() {
@@ -8223,7 +8196,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join69(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join68(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -8241,7 +8214,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = join69(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = join68(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -8276,7 +8249,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 };
 
 // src/features/subagents/copilot-subagent.ts
-import { join as join70 } from "path";
+import { join as join69 } from "path";
 import { z as z34 } from "zod/mini";
 var REQUIRED_TOOL = "agent/runSubagent";
 var CopilotSubagentFrontmatterSchema = z34.looseObject({
@@ -8302,7 +8275,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
       const result = CopilotSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${join70(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join69(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -8314,7 +8287,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: join70(".github", "agents")
+      relativeDirPath: join69(".github", "agents")
     };
   }
   getFrontmatter() {
@@ -8388,7 +8361,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${join70(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${join69(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -8406,7 +8379,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = join70(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = join69(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = CopilotSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -8441,24 +8414,171 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
   }
 };
 
-// src/features/subagents/kiro-subagent.ts
-import { join as join71 } from "path";
+// src/features/subagents/cursor-subagent.ts
+import { join as join70 } from "path";
 import { z as z35 } from "zod/mini";
-var KiroCliSubagentJsonSchema = z35.looseObject({
+var CursorSubagentFrontmatterSchema = z35.looseObject({
   name: z35.string(),
-  description: z35.optional(z35.nullable(z35.string())),
-  prompt: z35.optional(z35.nullable(z35.string())),
-  tools: z35.optional(z35.nullable(z35.array(z35.string()))),
-  toolAliases: z35.optional(z35.nullable(z35.record(z35.string(), z35.string()))),
-  toolSettings: z35.optional(z35.nullable(z35.unknown())),
-  toolSchema: z35.optional(z35.nullable(z35.unknown())),
-  hooks: z35.optional(z35.nullable(z35.record(z35.string(), z35.array(z35.unknown())))),
-  model: z35.optional(z35.nullable(z35.string())),
-  mcpServers: z35.optional(z35.nullable(z35.record(z35.string(), z35.unknown()))),
-  useLegacyMcpJson: z35.optional(z35.nullable(z35.boolean())),
-  resources: z35.optional(z35.nullable(z35.array(z35.string()))),
-  allowedTools: z35.optional(z35.nullable(z35.array(z35.string()))),
-  includeMcpJson: z35.optional(z35.nullable(z35.boolean()))
+  description: z35.string()
+});
+var CursorSubagent = class _CursorSubagent extends ToolSubagent {
+  frontmatter;
+  body;
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = CursorSubagentFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${join70(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+        );
+      }
+    }
+    super({
+      ...rest
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: join70(".cursor", "agents")
+    };
+  }
+  getFrontmatter() {
+    return this.frontmatter;
+  }
+  getBody() {
+    return this.body;
+  }
+  toRulesyncSubagent() {
+    const { name, description, ...rest } = this.frontmatter;
+    const rulesyncFrontmatter = {
+      targets: ["*"],
+      name,
+      description,
+      cursor: {
+        ...rest
+      }
+    };
+    return new RulesyncSubagent({
+      baseDir: ".",
+      // RulesyncSubagent baseDir is always the project root directory
+      frontmatter: rulesyncFrontmatter,
+      body: this.body,
+      relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
+      relativeFilePath: this.getRelativeFilePath(),
+      validate: true
+    });
+  }
+  static fromRulesyncSubagent({
+    baseDir = process.cwd(),
+    rulesyncSubagent,
+    validate = true,
+    global = false
+  }) {
+    const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
+    const cursorSection = rulesyncFrontmatter.cursor ?? {};
+    const cursorFrontmatter = {
+      name: rulesyncFrontmatter.name,
+      description: rulesyncFrontmatter.description,
+      ...cursorSection
+    };
+    const body = rulesyncSubagent.getBody();
+    const fileContent = stringifyFrontmatter(body, cursorFrontmatter);
+    const paths = this.getSettablePaths({ global });
+    return new _CursorSubagent({
+      baseDir,
+      frontmatter: cursorFrontmatter,
+      body,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+      fileContent,
+      validate,
+      global
+    });
+  }
+  validate() {
+    if (!this.frontmatter) {
+      return { success: true, error: null };
+    }
+    const result = CursorSubagentFrontmatterSchema.safeParse(this.frontmatter);
+    if (result.success) {
+      return { success: true, error: null };
+    } else {
+      return {
+        success: false,
+        error: new Error(
+          `Invalid frontmatter in ${join70(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+        )
+      };
+    }
+  }
+  static isTargetedByRulesyncSubagent(rulesyncSubagent) {
+    return this.isTargetedByRulesyncSubagentDefault({
+      rulesyncSubagent,
+      toolTarget: "cursor"
+    });
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    relativeFilePath,
+    validate = true,
+    global = false
+  }) {
+    const paths = this.getSettablePaths({ global });
+    const filePath = join70(baseDir, paths.relativeDirPath, relativeFilePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent);
+    const result = CursorSubagentFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+    }
+    return new _CursorSubagent({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath,
+      frontmatter: result.data,
+      body: content.trim(),
+      fileContent,
+      validate,
+      global
+    });
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _CursorSubagent({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      frontmatter: { name: "", description: "" },
+      body: "",
+      fileContent: "",
+      validate: false
+    });
+  }
+};
+
+// src/features/subagents/kiro-subagent.ts
+import { join as join71 } from "path";
+import { z as z36 } from "zod/mini";
+var KiroCliSubagentJsonSchema = z36.looseObject({
+  name: z36.string(),
+  description: z36.optional(z36.nullable(z36.string())),
+  prompt: z36.optional(z36.nullable(z36.string())),
+  tools: z36.optional(z36.nullable(z36.array(z36.string()))),
+  toolAliases: z36.optional(z36.nullable(z36.record(z36.string(), z36.string()))),
+  toolSettings: z36.optional(z36.nullable(z36.unknown())),
+  toolSchema: z36.optional(z36.nullable(z36.unknown())),
+  hooks: z36.optional(z36.nullable(z36.record(z36.string(), z36.array(z36.unknown())))),
+  model: z36.optional(z36.nullable(z36.string())),
+  mcpServers: z36.optional(z36.nullable(z36.record(z36.string(), z36.unknown()))),
+  useLegacyMcpJson: z36.optional(z36.nullable(z36.boolean())),
+  resources: z36.optional(z36.nullable(z36.array(z36.string()))),
+  allowedTools: z36.optional(z36.nullable(z36.array(z36.string()))),
+  includeMcpJson: z36.optional(z36.nullable(z36.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -8580,11 +8700,11 @@ var KiroSubagent = class _KiroSubagent extends ToolSubagent {
 
 // src/features/subagents/opencode-subagent.ts
 import { basename as basename20, join as join72 } from "path";
-import { z as z36 } from "zod/mini";
-var OpenCodeSubagentFrontmatterSchema = z36.looseObject({
-  description: z36.string(),
-  mode: z36.literal("subagent"),
-  name: z36.optional(z36.string())
+import { z as z37 } from "zod/mini";
+var OpenCodeSubagentFrontmatterSchema = z37.looseObject({
+  description: z37.string(),
+  mode: z37.literal("subagent"),
+  name: z37.optional(z37.string())
 });
 var OpenCodeSubagent = class _OpenCodeSubagent extends ToolSubagent {
   frontmatter;
@@ -8739,7 +8859,7 @@ var subagentsProcessorToolTargetTuple = [
   "opencode",
   "roo"
 ];
-var SubagentsProcessorToolTargetSchema = z37.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = z38.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -8780,7 +8900,7 @@ var toolSubagentFactories = /* @__PURE__ */ new Map([
     "cursor",
     {
       class: CursorSubagent,
-      meta: { supportsSimulated: true, supportsGlobal: false, filePattern: "*.md" }
+      meta: { supportsSimulated: false, supportsGlobal: false, filePattern: "*.md" }
     }
   ],
   [
@@ -8995,42 +9115,42 @@ import { join as join75 } from "path";
 
 // src/features/rules/rulesync-rule.ts
 import { join as join74 } from "path";
-import { z as z38 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z38.object({
-  root: z38.optional(z38.boolean()),
-  localRoot: z38.optional(z38.boolean()),
-  targets: z38.optional(RulesyncTargetsSchema),
-  description: z38.optional(z38.string()),
-  globs: z38.optional(z38.array(z38.string())),
-  agentsmd: z38.optional(
-    z38.object({
+import { z as z39 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z39.object({
+  root: z39.optional(z39.boolean()),
+  localRoot: z39.optional(z39.boolean()),
+  targets: z39.optional(RulesyncTargetsSchema),
+  description: z39.optional(z39.string()),
+  globs: z39.optional(z39.array(z39.string())),
+  agentsmd: z39.optional(
+    z39.object({
       // @example "path/to/subproject"
-      subprojectPath: z38.optional(z38.string())
+      subprojectPath: z39.optional(z39.string())
     })
   ),
-  claudecode: z38.optional(
-    z38.object({
+  claudecode: z39.optional(
+    z39.object({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example "src/**/*.ts, tests/**/*.test.ts"
-      paths: z38.optional(z38.string())
+      paths: z39.optional(z39.string())
     })
   ),
-  cursor: z38.optional(
-    z38.object({
-      alwaysApply: z38.optional(z38.boolean()),
-      description: z38.optional(z38.string()),
-      globs: z38.optional(z38.array(z38.string()))
+  cursor: z39.optional(
+    z39.object({
+      alwaysApply: z39.optional(z39.boolean()),
+      description: z39.optional(z39.string()),
+      globs: z39.optional(z39.array(z39.string()))
     })
   ),
-  copilot: z38.optional(
-    z38.object({
-      excludeAgent: z38.optional(z38.union([z38.literal("code-review"), z38.literal("coding-agent")]))
+  copilot: z39.optional(
+    z39.object({
+      excludeAgent: z39.optional(z39.union([z39.literal("code-review"), z39.literal("coding-agent")]))
     })
   ),
-  antigravity: z38.optional(
-    z38.looseObject({
-      trigger: z38.optional(z38.string()),
-      globs: z38.optional(z38.array(z38.string()))
+  antigravity: z39.optional(
+    z39.looseObject({
+      trigger: z39.optional(z39.string()),
+      globs: z39.optional(z39.array(z39.string()))
     })
   )
 });
@@ -9331,20 +9451,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 import { join as join77 } from "path";
-import { z as z39 } from "zod/mini";
-var AntigravityRuleFrontmatterSchema = z39.looseObject({
-  trigger: z39.optional(
-    z39.union([
-      z39.literal("always_on"),
-      z39.literal("glob"),
-      z39.literal("manual"),
-      z39.literal("model_decision"),
-      z39.string()
+import { z as z40 } from "zod/mini";
+var AntigravityRuleFrontmatterSchema = z40.looseObject({
+  trigger: z40.optional(
+    z40.union([
+      z40.literal("always_on"),
+      z40.literal("glob"),
+      z40.literal("manual"),
+      z40.literal("model_decision"),
+      z40.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: z39.optional(z39.string()),
-  description: z39.optional(z39.string())
+  globs: z40.optional(z40.string()),
+  description: z40.optional(z40.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -9922,9 +10042,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 import { join as join81 } from "path";
-import { z as z40 } from "zod/mini";
-var ClaudecodeRuleFrontmatterSchema = z40.object({
-  paths: z40.optional(z40.string())
+import { z as z41 } from "zod/mini";
+var ClaudecodeRuleFrontmatterSchema = z41.object({
+  paths: z41.optional(z41.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -10132,9 +10252,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 import { join as join82 } from "path";
-import { z as z41 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z41.object({
-  description: z41.string()
+import { z as z42 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z42.object({
+  description: z42.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -10311,11 +10431,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 import { join as join84 } from "path";
-import { z as z42 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z42.object({
-  description: z42.optional(z42.string()),
-  applyTo: z42.optional(z42.string()),
-  excludeAgent: z42.optional(z42.union([z42.literal("code-review"), z42.literal("coding-agent")]))
+import { z as z43 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z43.object({
+  description: z43.optional(z43.string()),
+  applyTo: z43.optional(z43.string()),
+  excludeAgent: z43.optional(z43.union([z43.literal("code-review"), z43.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -10499,11 +10619,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 import { join as join85 } from "path";
-import { z as z43 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z43.object({
-  description: z43.optional(z43.string()),
-  globs: z43.optional(z43.string()),
-  alwaysApply: z43.optional(z43.boolean())
+import { z as z44 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z44.object({
+  description: z44.optional(z44.string()),
+  globs: z44.optional(z44.string()),
+  alwaysApply: z44.optional(z44.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -11509,7 +11629,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z44.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z45.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -11601,11 +11721,7 @@ var toolRuleFactories = /* @__PURE__ */ new Map([
       meta: {
         extension: "mdc",
         supportsGlobal: false,
-        ruleDiscoveryMode: "auto",
-        additionalConventions: {
-          subagents: { subagentClass: CursorSubagent }
-        },
-        createsSeparateConventionsRule: true
+        ruleDiscoveryMode: "auto"
       }
     }
   ],
@@ -13061,11 +13177,11 @@ Keep the summary concise and ready to reuse in future tasks.`
 import { FastMCP } from "fastmcp";
 
 // src/mcp/tools.ts
-import { z as z51 } from "zod/mini";
+import { z as z52 } from "zod/mini";
 
 // src/mcp/commands.ts
 import { basename as basename23, join as join100 } from "path";
-import { z as z45 } from "zod/mini";
+import { z as z46 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -13184,17 +13300,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: z45.object({}),
-  getCommand: z45.object({
-    relativePathFromCwd: z45.string()
+  listCommands: z46.object({}),
+  getCommand: z46.object({
+    relativePathFromCwd: z46.string()
   }),
-  putCommand: z45.object({
-    relativePathFromCwd: z45.string(),
+  putCommand: z46.object({
+    relativePathFromCwd: z46.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: z45.string()
+    body: z46.string()
   }),
-  deleteCommand: z45.object({
-    relativePathFromCwd: z45.string()
+  deleteCommand: z46.object({
+    relativePathFromCwd: z46.string()
   })
 };
 var commandTools = {
@@ -13243,7 +13359,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 import { join as join101 } from "path";
-import { z as z46 } from "zod/mini";
+import { z as z47 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = join101(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -13300,11 +13416,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z46.object({}),
-  putIgnoreFile: z46.object({
-    content: z46.string()
+  getIgnoreFile: z47.object({}),
+  putIgnoreFile: z47.object({
+    content: z47.string()
   }),
-  deleteIgnoreFile: z46.object({})
+  deleteIgnoreFile: z47.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -13338,7 +13454,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 import { join as join102 } from "path";
-import { z as z47 } from "zod/mini";
+import { z as z48 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -13428,11 +13544,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z47.object({}),
-  putMcpFile: z47.object({
-    content: z47.string()
+  getMcpFile: z48.object({}),
+  putMcpFile: z48.object({
+    content: z48.string()
   }),
-  deleteMcpFile: z47.object({})
+  deleteMcpFile: z48.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -13466,7 +13582,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 import { basename as basename24, join as join103 } from "path";
-import { z as z48 } from "zod/mini";
+import { z as z49 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -13585,17 +13701,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z48.object({}),
-  getRule: z48.object({
-    relativePathFromCwd: z48.string()
+  listRules: z49.object({}),
+  getRule: z49.object({
+    relativePathFromCwd: z49.string()
   }),
-  putRule: z48.object({
-    relativePathFromCwd: z48.string(),
+  putRule: z49.object({
+    relativePathFromCwd: z49.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z48.string()
+    body: z49.string()
   }),
-  deleteRule: z48.object({
-    relativePathFromCwd: z48.string()
+  deleteRule: z49.object({
+    relativePathFromCwd: z49.string()
   })
 };
 var ruleTools = {
@@ -13644,7 +13760,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 import { basename as basename25, dirname as dirname3, join as join104 } from "path";
-import { z as z49 } from "zod/mini";
+import { z as z50 } from "zod/mini";
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -13812,23 +13928,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = z49.object({
-  name: z49.string(),
-  body: z49.string()
+var McpSkillFileSchema = z50.object({
+  name: z50.string(),
+  body: z50.string()
 });
 var skillToolSchemas = {
-  listSkills: z49.object({}),
-  getSkill: z49.object({
-    relativeDirPathFromCwd: z49.string()
+  listSkills: z50.object({}),
+  getSkill: z50.object({
+    relativeDirPathFromCwd: z50.string()
   }),
-  putSkill: z49.object({
-    relativeDirPathFromCwd: z49.string(),
+  putSkill: z50.object({
+    relativeDirPathFromCwd: z50.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: z49.string(),
-    otherFiles: z49.optional(z49.array(McpSkillFileSchema))
+    body: z50.string(),
+    otherFiles: z50.optional(z50.array(McpSkillFileSchema))
   }),
-  deleteSkill: z49.object({
-    relativeDirPathFromCwd: z49.string()
+  deleteSkill: z50.object({
+    relativeDirPathFromCwd: z50.string()
   })
 };
 var skillTools = {
@@ -13878,7 +13994,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 import { basename as basename26, join as join105 } from "path";
-import { z as z50 } from "zod/mini";
+import { z as z51 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -14002,17 +14118,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z50.object({}),
-  getSubagent: z50.object({
-    relativePathFromCwd: z50.string()
+  listSubagents: z51.object({}),
+  getSubagent: z51.object({
+    relativePathFromCwd: z51.string()
   }),
-  putSubagent: z50.object({
-    relativePathFromCwd: z50.string(),
+  putSubagent: z51.object({
+    relativePathFromCwd: z51.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z50.string()
+    body: z51.string()
   }),
-  deleteSubagent: z50.object({
-    relativePathFromCwd: z50.string()
+  deleteSubagent: z51.object({
+    relativePathFromCwd: z51.string()
   })
 };
 var subagentTools = {
@@ -14060,20 +14176,20 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = z51.enum(["rule", "command", "subagent", "skill", "ignore", "mcp"]);
-var rulesyncOperationSchema = z51.enum(["list", "get", "put", "delete"]);
-var skillFileSchema = z51.object({
-  name: z51.string(),
-  body: z51.string()
+var rulesyncFeatureSchema = z52.enum(["rule", "command", "subagent", "skill", "ignore", "mcp"]);
+var rulesyncOperationSchema = z52.enum(["list", "get", "put", "delete"]);
+var skillFileSchema = z52.object({
+  name: z52.string(),
+  body: z52.string()
 });
-var rulesyncToolSchema = z51.object({
+var rulesyncToolSchema = z52.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: z51.optional(z51.string()),
-  frontmatter: z51.optional(z51.unknown()),
-  body: z51.optional(z51.string()),
-  otherFiles: z51.optional(z51.array(skillFileSchema)),
-  content: z51.optional(z51.string())
+  targetPathFromCwd: z52.optional(z52.string()),
+  frontmatter: z52.optional(z52.unknown()),
+  body: z52.optional(z52.string()),
+  otherFiles: z52.optional(z52.array(skillFileSchema)),
+  content: z52.optional(z52.string())
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -14269,7 +14385,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "6.1.1";
+var getVersion = () => "6.2.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();
@@ -14336,7 +14452,7 @@ var main = async () => {
     "Generate simulated commands. This feature is only available for copilot, cursor and codexcli."
   ).option(
     "--simulate-subagents",
-    "Generate simulated subagents. This feature is only available for copilot, cursor and codexcli."
+    "Generate simulated subagents. This feature is only available for copilot and codexcli."
   ).option(
     "--simulate-skills",
     "Generate simulated skills. This feature is only available for copilot, cursor and codexcli."