rulesync 6.1.1 → 6.2.0

package/dist/index.cjs

@@ -5347,7 +5347,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_toon = require("@toon-format/toon");
 var import_node_path97 = require("path");
-var import_mini44 = require("zod/mini");
+var import_mini45 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -7978,39 +7978,12 @@ var CodexCliSubagent = class _CodexCliSubagent extends SimulatedSubagent {
   }
 };
 
-// src/features/subagents/cursor-subagent.ts
-var import_node_path66 = require("path");
-var CursorSubagent = class _CursorSubagent extends SimulatedSubagent {
-  static getSettablePaths() {
-    return {
-      relativeDirPath: (0, import_node_path66.join)(".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
-var import_node_path67 = require("path");
+var import_node_path66 = require("path");
 var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path67.join)(".gemini", "subagents")
+      relativeDirPath: (0, import_node_path66.join)(".gemini", "subagents")
     };
   }
   static async fromFile(params) {
@@ -8033,11 +8006,11 @@ var GeminiCliSubagent = class _GeminiCliSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/roo-subagent.ts
-var import_node_path68 = require("path");
+var import_node_path67 = require("path");
 var RooSubagent = class _RooSubagent extends SimulatedSubagent {
   static getSettablePaths() {
     return {
-      relativeDirPath: (0, import_node_path68.join)(".roo", "subagents")
+      relativeDirPath: (0, import_node_path67.join)(".roo", "subagents")
     };
   }
   static async fromFile(params) {
@@ -8061,14 +8034,14 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path74 = require("path");
-var import_mini37 = require("zod/mini");
+var import_mini38 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
-var import_node_path70 = require("path");
+var import_node_path69 = require("path");
 var import_mini33 = require("zod/mini");
 
 // src/features/subagents/rulesync-subagent.ts
-var import_node_path69 = require("path");
+var import_node_path68 = require("path");
 var import_mini32 = require("zod/mini");
 var RulesyncSubagentFrontmatterSchema = import_mini32.z.looseObject({
   targets: RulesyncTargetsSchema,
@@ -8083,7 +8056,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path69.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path68.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -8116,7 +8089,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path69.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path68.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -8125,14 +8098,14 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
     relativeFilePath
   }) {
     const fileContent = await readFileContent(
-      (0, import_node_path69.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
+      (0, import_node_path68.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, relativeFilePath)
     );
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = RulesyncSubagentFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
     }
-    const filename = (0, import_node_path69.basename)(relativeFilePath);
+    const filename = (0, import_node_path68.basename)(relativeFilePath);
     return new _RulesyncSubagent({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().relativeDirPath,
@@ -8160,7 +8133,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path70.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path69.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -8172,7 +8145,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: (0, import_node_path70.join)(".claude", "agents")
+      relativeDirPath: (0, import_node_path69.join)(".claude", "agents")
     };
   }
   getFrontmatter() {
@@ -8246,7 +8219,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path70.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path69.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -8264,7 +8237,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = (0, import_node_path70.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path69.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = ClaudecodeSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -8299,7 +8272,7 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 };
 
 // src/features/subagents/copilot-subagent.ts
-var import_node_path71 = require("path");
+var import_node_path70 = require("path");
 var import_mini34 = require("zod/mini");
 var REQUIRED_TOOL = "agent/runSubagent";
 var CopilotSubagentFrontmatterSchema = import_mini34.z.looseObject({
@@ -8325,7 +8298,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
       const result = CopilotSubagentFrontmatterSchema.safeParse(frontmatter);
       if (!result.success) {
         throw new Error(
-          `Invalid frontmatter in ${(0, import_node_path71.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path70.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
         );
       }
     }
@@ -8337,7 +8310,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
   }
   static getSettablePaths(_options = {}) {
     return {
-      relativeDirPath: (0, import_node_path71.join)(".github", "agents")
+      relativeDirPath: (0, import_node_path70.join)(".github", "agents")
     };
   }
   getFrontmatter() {
@@ -8411,7 +8384,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
       return {
         success: false,
         error: new Error(
-          `Invalid frontmatter in ${(0, import_node_path71.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
+          `Invalid frontmatter in ${(0, import_node_path70.join)(this.relativeDirPath, this.relativeFilePath)}: ${formatError(result.error)}`
         )
       };
     }
@@ -8429,7 +8402,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
     global = false
   }) {
     const paths = this.getSettablePaths({ global });
-    const filePath = (0, import_node_path71.join)(baseDir, paths.relativeDirPath, relativeFilePath);
+    const filePath = (0, import_node_path70.join)(baseDir, paths.relativeDirPath, relativeFilePath);
     const fileContent = await readFileContent(filePath);
     const { frontmatter, body: content } = parseFrontmatter(fileContent);
     const result = CopilotSubagentFrontmatterSchema.safeParse(frontmatter);
@@ -8464,24 +8437,171 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
   }
 };
 
-// src/features/subagents/kiro-subagent.ts
-var import_node_path72 = require("path");
+// src/features/subagents/cursor-subagent.ts
+var import_node_path71 = require("path");
 var import_mini35 = require("zod/mini");
-var KiroCliSubagentJsonSchema = import_mini35.z.looseObject({
+var CursorSubagentFrontmatterSchema = import_mini35.z.looseObject({
   name: import_mini35.z.string(),
-  description: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.string())),
-  prompt: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.string())),
-  tools: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.array(import_mini35.z.string()))),
-  toolAliases: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.record(import_mini35.z.string(), import_mini35.z.string()))),
-  toolSettings: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.unknown())),
-  toolSchema: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.unknown())),
-  hooks: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.record(import_mini35.z.string(), import_mini35.z.array(import_mini35.z.unknown())))),
-  model: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.string())),
-  mcpServers: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.record(import_mini35.z.string(), import_mini35.z.unknown()))),
-  useLegacyMcpJson: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.boolean())),
-  resources: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.array(import_mini35.z.string()))),
-  allowedTools: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.array(import_mini35.z.string()))),
-  includeMcpJson: import_mini35.z.optional(import_mini35.z.nullable(import_mini35.z.boolean()))
+  description: import_mini35.z.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 ${(0, import_node_path71.join)(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+        );
+      }
+    }
+    super({
+      ...rest
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: (0, import_node_path71.join)(".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 ${(0, import_node_path71.join)(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 = (0, import_node_path71.join)(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
+var import_node_path72 = require("path");
+var import_mini36 = require("zod/mini");
+var KiroCliSubagentJsonSchema = import_mini36.z.looseObject({
+  name: import_mini36.z.string(),
+  description: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.string())),
+  prompt: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.string())),
+  tools: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.array(import_mini36.z.string()))),
+  toolAliases: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.record(import_mini36.z.string(), import_mini36.z.string()))),
+  toolSettings: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.unknown())),
+  toolSchema: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.unknown())),
+  hooks: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.record(import_mini36.z.string(), import_mini36.z.array(import_mini36.z.unknown())))),
+  model: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.string())),
+  mcpServers: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.record(import_mini36.z.string(), import_mini36.z.unknown()))),
+  useLegacyMcpJson: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.boolean())),
+  resources: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.array(import_mini36.z.string()))),
+  allowedTools: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.array(import_mini36.z.string()))),
+  includeMcpJson: import_mini36.z.optional(import_mini36.z.nullable(import_mini36.z.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -8603,11 +8723,11 @@ var KiroSubagent = class _KiroSubagent extends ToolSubagent {
 
 // src/features/subagents/opencode-subagent.ts
 var import_node_path73 = require("path");
-var import_mini36 = require("zod/mini");
-var OpenCodeSubagentFrontmatterSchema = import_mini36.z.looseObject({
-  description: import_mini36.z.string(),
-  mode: import_mini36.z.literal("subagent"),
-  name: import_mini36.z.optional(import_mini36.z.string())
+var import_mini37 = require("zod/mini");
+var OpenCodeSubagentFrontmatterSchema = import_mini37.z.looseObject({
+  description: import_mini37.z.string(),
+  mode: import_mini37.z.literal("subagent"),
+  name: import_mini37.z.optional(import_mini37.z.string())
 });
 var OpenCodeSubagent = class _OpenCodeSubagent extends ToolSubagent {
   frontmatter;
@@ -8762,7 +8882,7 @@ var subagentsProcessorToolTargetTuple = [
   "opencode",
   "roo"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini37.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini38.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -8803,7 +8923,7 @@ var toolSubagentFactories = /* @__PURE__ */ new Map([
     "cursor",
     {
       class: CursorSubagent,
-      meta: { supportsSimulated: true, supportsGlobal: false, filePattern: "*.md" }
+      meta: { supportsSimulated: false, supportsGlobal: false, filePattern: "*.md" }
     }
   ],
   [
@@ -9018,42 +9138,42 @@ var import_node_path76 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path75 = require("path");
-var import_mini38 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini38.z.object({
-  root: import_mini38.z.optional(import_mini38.z.boolean()),
-  localRoot: import_mini38.z.optional(import_mini38.z.boolean()),
-  targets: import_mini38.z.optional(RulesyncTargetsSchema),
-  description: import_mini38.z.optional(import_mini38.z.string()),
-  globs: import_mini38.z.optional(import_mini38.z.array(import_mini38.z.string())),
-  agentsmd: import_mini38.z.optional(
-    import_mini38.z.object({
+var import_mini39 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini39.z.object({
+  root: import_mini39.z.optional(import_mini39.z.boolean()),
+  localRoot: import_mini39.z.optional(import_mini39.z.boolean()),
+  targets: import_mini39.z.optional(RulesyncTargetsSchema),
+  description: import_mini39.z.optional(import_mini39.z.string()),
+  globs: import_mini39.z.optional(import_mini39.z.array(import_mini39.z.string())),
+  agentsmd: import_mini39.z.optional(
+    import_mini39.z.object({
       // @example "path/to/subproject"
-      subprojectPath: import_mini38.z.optional(import_mini38.z.string())
+      subprojectPath: import_mini39.z.optional(import_mini39.z.string())
     })
   ),
-  claudecode: import_mini38.z.optional(
-    import_mini38.z.object({
+  claudecode: import_mini39.z.optional(
+    import_mini39.z.object({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example "src/**/*.ts, tests/**/*.test.ts"
-      paths: import_mini38.z.optional(import_mini38.z.string())
+      paths: import_mini39.z.optional(import_mini39.z.string())
     })
   ),
-  cursor: import_mini38.z.optional(
-    import_mini38.z.object({
-      alwaysApply: import_mini38.z.optional(import_mini38.z.boolean()),
-      description: import_mini38.z.optional(import_mini38.z.string()),
-      globs: import_mini38.z.optional(import_mini38.z.array(import_mini38.z.string()))
+  cursor: import_mini39.z.optional(
+    import_mini39.z.object({
+      alwaysApply: import_mini39.z.optional(import_mini39.z.boolean()),
+      description: import_mini39.z.optional(import_mini39.z.string()),
+      globs: import_mini39.z.optional(import_mini39.z.array(import_mini39.z.string()))
     })
   ),
-  copilot: import_mini38.z.optional(
-    import_mini38.z.object({
-      excludeAgent: import_mini38.z.optional(import_mini38.z.union([import_mini38.z.literal("code-review"), import_mini38.z.literal("coding-agent")]))
+  copilot: import_mini39.z.optional(
+    import_mini39.z.object({
+      excludeAgent: import_mini39.z.optional(import_mini39.z.union([import_mini39.z.literal("code-review"), import_mini39.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini38.z.optional(
-    import_mini38.z.looseObject({
-      trigger: import_mini38.z.optional(import_mini38.z.string()),
-      globs: import_mini38.z.optional(import_mini38.z.array(import_mini38.z.string()))
+  antigravity: import_mini39.z.optional(
+    import_mini39.z.looseObject({
+      trigger: import_mini39.z.optional(import_mini39.z.string()),
+      globs: import_mini39.z.optional(import_mini39.z.array(import_mini39.z.string()))
     })
   )
 });
@@ -9354,20 +9474,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path78 = require("path");
-var import_mini39 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini39.z.looseObject({
-  trigger: import_mini39.z.optional(
-    import_mini39.z.union([
-      import_mini39.z.literal("always_on"),
-      import_mini39.z.literal("glob"),
-      import_mini39.z.literal("manual"),
-      import_mini39.z.literal("model_decision"),
-      import_mini39.z.string()
+var import_mini40 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini40.z.looseObject({
+  trigger: import_mini40.z.optional(
+    import_mini40.z.union([
+      import_mini40.z.literal("always_on"),
+      import_mini40.z.literal("glob"),
+      import_mini40.z.literal("manual"),
+      import_mini40.z.literal("model_decision"),
+      import_mini40.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini39.z.optional(import_mini39.z.string()),
-  description: import_mini39.z.optional(import_mini39.z.string())
+  globs: import_mini40.z.optional(import_mini40.z.string()),
+  description: import_mini40.z.optional(import_mini40.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -9945,9 +10065,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path82 = require("path");
-var import_mini40 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini40.z.object({
-  paths: import_mini40.z.optional(import_mini40.z.string())
+var import_mini41 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini41.z.object({
+  paths: import_mini41.z.optional(import_mini41.z.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -10155,9 +10275,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path83 = require("path");
-var import_mini41 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini41.z.object({
-  description: import_mini41.z.string()
+var import_mini42 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini42.z.object({
+  description: import_mini42.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -10334,11 +10454,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path85 = require("path");
-var import_mini42 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini42.z.object({
-  description: import_mini42.z.optional(import_mini42.z.string()),
-  applyTo: import_mini42.z.optional(import_mini42.z.string()),
-  excludeAgent: import_mini42.z.optional(import_mini42.z.union([import_mini42.z.literal("code-review"), import_mini42.z.literal("coding-agent")]))
+var import_mini43 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini43.z.object({
+  description: import_mini43.z.optional(import_mini43.z.string()),
+  applyTo: import_mini43.z.optional(import_mini43.z.string()),
+  excludeAgent: import_mini43.z.optional(import_mini43.z.union([import_mini43.z.literal("code-review"), import_mini43.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -10522,11 +10642,11 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path86 = require("path");
-var import_mini43 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini43.z.object({
-  description: import_mini43.z.optional(import_mini43.z.string()),
-  globs: import_mini43.z.optional(import_mini43.z.string()),
-  alwaysApply: import_mini43.z.optional(import_mini43.z.boolean())
+var import_mini44 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini44.z.object({
+  description: import_mini44.z.optional(import_mini44.z.string()),
+  globs: import_mini44.z.optional(import_mini44.z.string()),
+  alwaysApply: import_mini44.z.optional(import_mini44.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -11532,7 +11652,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini44.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini45.z.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -11624,11 +11744,7 @@ var toolRuleFactories = /* @__PURE__ */ new Map([
       meta: {
         extension: "mdc",
         supportsGlobal: false,
-        ruleDiscoveryMode: "auto",
-        additionalConventions: {
-          subagents: { subagentClass: CursorSubagent }
-        },
-        createsSeparateConventionsRule: true
+        ruleDiscoveryMode: "auto"
       }
     }
   ],
@@ -13084,11 +13200,11 @@ Keep the summary concise and ready to reuse in future tasks.`
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini51 = require("zod/mini");
+var import_mini52 = require("zod/mini");
 
 // src/mcp/commands.ts
 var import_node_path101 = require("path");
-var import_mini45 = require("zod/mini");
+var import_mini46 = require("zod/mini");
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -13207,17 +13323,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini45.z.object({}),
-  getCommand: import_mini45.z.object({
-    relativePathFromCwd: import_mini45.z.string()
+  listCommands: import_mini46.z.object({}),
+  getCommand: import_mini46.z.object({
+    relativePathFromCwd: import_mini46.z.string()
   }),
-  putCommand: import_mini45.z.object({
-    relativePathFromCwd: import_mini45.z.string(),
+  putCommand: import_mini46.z.object({
+    relativePathFromCwd: import_mini46.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini45.z.string()
+    body: import_mini46.z.string()
   }),
-  deleteCommand: import_mini45.z.object({
-    relativePathFromCwd: import_mini45.z.string()
+  deleteCommand: import_mini46.z.object({
+    relativePathFromCwd: import_mini46.z.string()
   })
 };
 var commandTools = {
@@ -13266,7 +13382,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 var import_node_path102 = require("path");
-var import_mini46 = require("zod/mini");
+var import_mini47 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path102.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -13323,11 +13439,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini46.z.object({}),
-  putIgnoreFile: import_mini46.z.object({
-    content: import_mini46.z.string()
+  getIgnoreFile: import_mini47.z.object({}),
+  putIgnoreFile: import_mini47.z.object({
+    content: import_mini47.z.string()
   }),
-  deleteIgnoreFile: import_mini46.z.object({})
+  deleteIgnoreFile: import_mini47.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -13361,7 +13477,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 var import_node_path103 = require("path");
-var import_mini47 = require("zod/mini");
+var import_mini48 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -13451,11 +13567,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini47.z.object({}),
-  putMcpFile: import_mini47.z.object({
-    content: import_mini47.z.string()
+  getMcpFile: import_mini48.z.object({}),
+  putMcpFile: import_mini48.z.object({
+    content: import_mini48.z.string()
   }),
-  deleteMcpFile: import_mini47.z.object({})
+  deleteMcpFile: import_mini48.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -13489,7 +13605,7 @@ var mcpTools = {
 
 // src/mcp/rules.ts
 var import_node_path104 = require("path");
-var import_mini48 = require("zod/mini");
+var import_mini49 = require("zod/mini");
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -13608,17 +13724,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini48.z.object({}),
-  getRule: import_mini48.z.object({
-    relativePathFromCwd: import_mini48.z.string()
+  listRules: import_mini49.z.object({}),
+  getRule: import_mini49.z.object({
+    relativePathFromCwd: import_mini49.z.string()
   }),
-  putRule: import_mini48.z.object({
-    relativePathFromCwd: import_mini48.z.string(),
+  putRule: import_mini49.z.object({
+    relativePathFromCwd: import_mini49.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini48.z.string()
+    body: import_mini49.z.string()
   }),
-  deleteRule: import_mini48.z.object({
-    relativePathFromCwd: import_mini48.z.string()
+  deleteRule: import_mini49.z.object({
+    relativePathFromCwd: import_mini49.z.string()
   })
 };
 var ruleTools = {
@@ -13667,7 +13783,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path105 = require("path");
-var import_mini49 = require("zod/mini");
+var import_mini50 = require("zod/mini");
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -13835,23 +13951,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini49.z.object({
-  name: import_mini49.z.string(),
-  body: import_mini49.z.string()
+var McpSkillFileSchema = import_mini50.z.object({
+  name: import_mini50.z.string(),
+  body: import_mini50.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini49.z.object({}),
-  getSkill: import_mini49.z.object({
-    relativeDirPathFromCwd: import_mini49.z.string()
+  listSkills: import_mini50.z.object({}),
+  getSkill: import_mini50.z.object({
+    relativeDirPathFromCwd: import_mini50.z.string()
   }),
-  putSkill: import_mini49.z.object({
-    relativeDirPathFromCwd: import_mini49.z.string(),
+  putSkill: import_mini50.z.object({
+    relativeDirPathFromCwd: import_mini50.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini49.z.string(),
-    otherFiles: import_mini49.z.optional(import_mini49.z.array(McpSkillFileSchema))
+    body: import_mini50.z.string(),
+    otherFiles: import_mini50.z.optional(import_mini50.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini49.z.object({
-    relativeDirPathFromCwd: import_mini49.z.string()
+  deleteSkill: import_mini50.z.object({
+    relativeDirPathFromCwd: import_mini50.z.string()
   })
 };
 var skillTools = {
@@ -13901,7 +14017,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path106 = require("path");
-var import_mini50 = require("zod/mini");
+var import_mini51 = require("zod/mini");
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -14025,17 +14141,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini50.z.object({}),
-  getSubagent: import_mini50.z.object({
-    relativePathFromCwd: import_mini50.z.string()
+  listSubagents: import_mini51.z.object({}),
+  getSubagent: import_mini51.z.object({
+    relativePathFromCwd: import_mini51.z.string()
   }),
-  putSubagent: import_mini50.z.object({
-    relativePathFromCwd: import_mini50.z.string(),
+  putSubagent: import_mini51.z.object({
+    relativePathFromCwd: import_mini51.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini50.z.string()
+    body: import_mini51.z.string()
   }),
-  deleteSubagent: import_mini50.z.object({
-    relativePathFromCwd: import_mini50.z.string()
+  deleteSubagent: import_mini51.z.object({
+    relativePathFromCwd: import_mini51.z.string()
   })
 };
 var subagentTools = {
@@ -14083,20 +14199,20 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini51.z.enum(["rule", "command", "subagent", "skill", "ignore", "mcp"]);
-var rulesyncOperationSchema = import_mini51.z.enum(["list", "get", "put", "delete"]);
-var skillFileSchema = import_mini51.z.object({
-  name: import_mini51.z.string(),
-  body: import_mini51.z.string()
+var rulesyncFeatureSchema = import_mini52.z.enum(["rule", "command", "subagent", "skill", "ignore", "mcp"]);
+var rulesyncOperationSchema = import_mini52.z.enum(["list", "get", "put", "delete"]);
+var skillFileSchema = import_mini52.z.object({
+  name: import_mini52.z.string(),
+  body: import_mini52.z.string()
 });
-var rulesyncToolSchema = import_mini51.z.object({
+var rulesyncToolSchema = import_mini52.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini51.z.optional(import_mini51.z.string()),
-  frontmatter: import_mini51.z.optional(import_mini51.z.unknown()),
-  body: import_mini51.z.optional(import_mini51.z.string()),
-  otherFiles: import_mini51.z.optional(import_mini51.z.array(skillFileSchema)),
-  content: import_mini51.z.optional(import_mini51.z.string())
+  targetPathFromCwd: import_mini52.z.optional(import_mini52.z.string()),
+  frontmatter: import_mini52.z.optional(import_mini52.z.unknown()),
+  body: import_mini52.z.optional(import_mini52.z.string()),
+  otherFiles: import_mini52.z.optional(import_mini52.z.array(skillFileSchema)),
+  content: import_mini52.z.optional(import_mini52.z.string())
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -14292,7 +14408,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 import_commander.Command();
   const version = getVersion();
@@ -14359,7 +14475,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."