rulesync 3.33.0 → 4.0.0

package/dist/index.js

@@ -89,7 +89,8 @@ import { parse as parseJsonc } from "jsonc-parser";
 import { globSync } from "fs";
 import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
 import os from "os";
-import { basename, dirname, join, relative, resolve } from "path";
+import { dirname, join, relative, resolve } from "path";
+import { kebabCase } from "es-toolkit";
 async function ensureDir(dirPath) {
   try {
     await stat(dirPath);
@@ -217,6 +218,13 @@ function validateBaseDir(baseDir) {
   }
   checkPathTraversal({ relativePath: baseDir, intendedRootDir: process.cwd() });
 }
+function toKebabCaseFilename(filename) {
+  const lastDotIndex = filename.lastIndexOf(".");
+  const extension = lastDotIndex > 0 ? filename.slice(lastDotIndex) : "";
+  const nameWithoutExt = lastDotIndex > 0 ? filename.slice(0, lastDotIndex) : filename;
+  const kebabName = kebabCase(nameWithoutExt);
+  return kebabName + extension;
+}
 
 // src/config/config.ts
 import { optional, z as z3 } from "zod/mini";
@@ -261,11 +269,7 @@ var ConfigParamsSchema = z3.object({
   simulateCommands: optional(z3.boolean()),
   simulateSubagents: optional(z3.boolean()),
   simulateSkills: optional(z3.boolean()),
-  modularMcp: optional(z3.boolean()),
-  // Deprecated experimental options (for backward compatibility)
-  experimentalGlobal: optional(z3.boolean()),
-  experimentalSimulateCommands: optional(z3.boolean()),
-  experimentalSimulateSubagents: optional(z3.boolean())
+  modularMcp: optional(z3.boolean())
 });
 var PartialConfigParamsSchema = z3.partial(ConfigParamsSchema);
 var ConfigFileSchema = z3.object({
@@ -299,10 +303,7 @@ var Config = class {
     simulateCommands,
     simulateSubagents,
     simulateSkills,
-    modularMcp,
-    experimentalGlobal,
-    experimentalSimulateCommands,
-    experimentalSimulateSubagents
+    modularMcp
   }) {
     this.validateConflictingTargets(targets);
     this.baseDirs = baseDirs;
@@ -310,9 +311,9 @@ var Config = class {
     this.features = features;
     this.verbose = verbose;
     this.delete = isDelete;
-    this.global = global ?? experimentalGlobal ?? false;
-    this.simulateCommands = simulateCommands ?? experimentalSimulateCommands ?? false;
-    this.simulateSubagents = simulateSubagents ?? experimentalSimulateSubagents ?? false;
+    this.global = global ?? false;
+    this.simulateCommands = simulateCommands ?? false;
+    this.simulateSubagents = simulateSubagents ?? false;
     this.simulateSkills = simulateSkills ?? false;
     this.modularMcp = modularMcp ?? false;
   }
@@ -366,19 +367,6 @@ var Config = class {
   getModularMcp() {
     return this.modularMcp;
   }
-  // Deprecated getters for backward compatibility
-  /** @deprecated Use getGlobal() instead */
-  getExperimentalGlobal() {
-    return this.global;
-  }
-  /** @deprecated Use getSimulateCommands() instead */
-  getExperimentalSimulateCommands() {
-    return this.simulateCommands;
-  }
-  /** @deprecated Use getSimulateSubagents() instead */
-  getExperimentalSimulateSubagents() {
-    return this.simulateSubagents;
-  }
 };
 
 // src/config/config-resolver.ts
@@ -393,10 +381,7 @@ var getDefaults = () => ({
   simulateCommands: false,
   simulateSubagents: false,
   simulateSkills: false,
-  modularMcp: false,
-  experimentalGlobal: false,
-  experimentalSimulateCommands: false,
-  experimentalSimulateSubagents: false
+  modularMcp: false
 });
 var ConfigResolver = class {
   static async resolve({
@@ -410,10 +395,7 @@ var ConfigResolver = class {
     simulateCommands,
     simulateSubagents,
     simulateSkills,
-    modularMcp,
-    experimentalGlobal,
-    experimentalSimulateCommands,
-    experimentalSimulateSubagents
+    modularMcp
   }) {
     const validatedConfigPath = resolvePath(configPath, process.cwd());
     let configByFile = {};
@@ -429,21 +411,9 @@ var ConfigResolver = class {
         throw error;
       }
     }
-    const deprecatedGlobal = experimentalGlobal ?? configByFile.experimentalGlobal;
-    const deprecatedCommands = experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands;
-    const deprecatedSubagents = experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents;
-    if (deprecatedGlobal !== void 0) {
-      warnDeprecatedOptions({ experimentalGlobal: deprecatedGlobal });
-    }
-    if (deprecatedCommands !== void 0) {
-      warnDeprecatedOptions({ experimentalSimulateCommands: deprecatedCommands });
-    }
-    if (deprecatedSubagents !== void 0) {
-      warnDeprecatedOptions({ experimentalSimulateSubagents: deprecatedSubagents });
-    }
-    const resolvedGlobal = global ?? configByFile.global ?? experimentalGlobal ?? configByFile.experimentalGlobal ?? getDefaults().global;
-    const resolvedSimulateCommands = simulateCommands ?? configByFile.simulateCommands ?? experimentalSimulateCommands ?? configByFile.experimentalSimulateCommands ?? getDefaults().simulateCommands;
-    const resolvedSimulateSubagents = simulateSubagents ?? configByFile.simulateSubagents ?? experimentalSimulateSubagents ?? configByFile.experimentalSimulateSubagents ?? getDefaults().simulateSubagents;
+    const resolvedGlobal = global ?? configByFile.global ?? getDefaults().global;
+    const resolvedSimulateCommands = simulateCommands ?? configByFile.simulateCommands ?? getDefaults().simulateCommands;
+    const resolvedSimulateSubagents = simulateSubagents ?? configByFile.simulateSubagents ?? getDefaults().simulateSubagents;
     const resolvedSimulateSkills = simulateSkills ?? configByFile.simulateSkills ?? getDefaults().simulateSkills;
     const configParams = {
       targets: targets ?? configByFile.targets ?? getDefaults().targets,
@@ -463,25 +433,6 @@ var ConfigResolver = class {
     return new Config(configParams);
   }
 };
-function warnDeprecatedOptions({
-  experimentalGlobal,
-  experimentalSimulateCommands,
-  experimentalSimulateSubagents
-}) {
-  if (experimentalGlobal !== void 0) {
-    logger.warn("'experimentalGlobal' option is deprecated. Please use 'global' instead.");
-  }
-  if (experimentalSimulateCommands !== void 0) {
-    logger.warn(
-      "'experimentalSimulateCommands' option is deprecated. Please use 'simulateCommands' instead."
-    );
-  }
-  if (experimentalSimulateSubagents !== void 0) {
-    logger.warn(
-      "'experimentalSimulateSubagents' option is deprecated. Please use 'simulateSubagents' instead."
-    );
-  }
-}
 function getBaseDirsInLightOfGlobal({
   baseDirs,
   global
@@ -511,7 +462,7 @@ var RULESYNC_OVERVIEW_FILE_NAME = "overview.md";
 var RULESYNC_SKILLS_RELATIVE_DIR_PATH = join2(RULESYNC_RELATIVE_DIR_PATH, "skills");
 
 // src/features/commands/commands-processor.ts
-import { basename as basename13, join as join14 } from "path";
+import { basename as basename12, join as join14 } from "path";
 import { z as z12 } from "zod/mini";
 
 // src/types/feature-processor.ts
@@ -545,7 +496,7 @@ var FeatureProcessor = class {
 };
 
 // src/features/commands/agentsmd-command.ts
-import { basename as basename3, join as join4 } from "path";
+import { basename as basename2, join as join4 } from "path";
 
 // src/utils/frontmatter.ts
 import matter from "gray-matter";
@@ -597,7 +548,7 @@ function parseFrontmatter(content) {
 }
 
 // src/features/commands/simulated-command.ts
-import { basename as basename2, join as join3 } from "path";
+import { basename, join as join3 } from "path";
 import { z as z4 } from "zod/mini";
 
 // src/types/ai-file.ts
@@ -834,7 +785,7 @@ var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
     return {
       baseDir,
       relativeDirPath: _SimulatedCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath: basename2(relativeFilePath),
+      relativeFilePath: basename(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -877,7 +828,7 @@ var AgentsmdCommand = class _AgentsmdCommand extends SimulatedCommand {
     return new _AgentsmdCommand({
       baseDir,
       relativeDirPath: _AgentsmdCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath: basename3(relativeFilePath),
+      relativeFilePath: basename2(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -892,11 +843,11 @@ var AgentsmdCommand = class _AgentsmdCommand extends SimulatedCommand {
 };
 
 // src/features/commands/antigravity-command.ts
-import { basename as basename5, join as join6 } from "path";
+import { basename as basename4, join as join6 } from "path";
 import { z as z6 } from "zod/mini";
 
 // src/features/commands/rulesync-command.ts
-import { basename as basename4, join as join5 } from "path";
+import { basename as basename3, join as join5 } from "path";
 import { z as z5 } from "zod/mini";
 
 // src/types/rulesync-file.ts
@@ -974,7 +925,7 @@ var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
     }
-    const filename = basename4(relativeFilePath);
+    const filename = basename3(relativeFilePath);
     return new _RulesyncCommand({
       baseDir: process.cwd(),
       relativeDirPath: _RulesyncCommand.getSettablePaths().relativeDirPath,
@@ -1099,7 +1050,7 @@ var AntigravityCommand = class _AntigravityCommand extends ToolCommand {
     return new _AntigravityCommand({
       baseDir,
       relativeDirPath: _AntigravityCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath: basename5(relativeFilePath),
+      relativeFilePath: basename4(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       fileContent,
@@ -1109,7 +1060,7 @@ var AntigravityCommand = class _AntigravityCommand extends ToolCommand {
 };
 
 // src/features/commands/claudecode-command.ts
-import { basename as basename6, join as join7 } from "path";
+import { basename as basename5, join as join7 } from "path";
 import { z as z7 } from "zod/mini";
 var ClaudecodeCommandFrontmatterSchema = z7.looseObject({
   description: z7.string(),
@@ -1230,7 +1181,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
     return new _ClaudecodeCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: basename6(relativeFilePath),
+      relativeFilePath: basename5(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -1239,7 +1190,7 @@ var ClaudecodeCommand = class _ClaudecodeCommand extends ToolCommand {
 };
 
 // src/features/commands/codexcli-command.ts
-import { basename as basename7, join as join8 } from "path";
+import { basename as basename6, join as join8 } from "path";
 var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
   static getSettablePaths({ global } = {}) {
     if (!global) {
@@ -1305,7 +1256,7 @@ var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
     return new _CodexcliCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: basename7(relativeFilePath),
+      relativeFilePath: basename6(relativeFilePath),
       fileContent: content.trim(),
       validate
     });
@@ -1313,7 +1264,7 @@ var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
 };
 
 // src/features/commands/copilot-command.ts
-import { basename as basename8, join as join9 } from "path";
+import { basename as basename7, join as join9 } from "path";
 import { z as z8 } from "zod/mini";
 var CopilotCommandFrontmatterSchema = z8.looseObject({
   mode: z8.literal("agent"),
@@ -1426,7 +1377,7 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
     return new _CopilotCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: basename8(relativeFilePath),
+      relativeFilePath: basename7(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -1441,7 +1392,7 @@ var CopilotCommand = class _CopilotCommand extends ToolCommand {
 };
 
 // src/features/commands/cursor-command.ts
-import { basename as basename9, join as join10 } from "path";
+import { basename as basename8, join as join10 } from "path";
 var CursorCommand = class _CursorCommand extends ToolCommand {
   static getSettablePaths(_options = {}) {
     return {
@@ -1504,7 +1455,7 @@ var CursorCommand = class _CursorCommand extends ToolCommand {
     return new _CursorCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: basename9(relativeFilePath),
+      relativeFilePath: basename8(relativeFilePath),
       fileContent: content.trim(),
       validate
     });
@@ -1512,7 +1463,7 @@ var CursorCommand = class _CursorCommand extends ToolCommand {
 };
 
 // src/features/commands/geminicli-command.ts
-import { basename as basename10, join as join11 } from "path";
+import { basename as basename9, join as join11 } from "path";
 import { parse as parseToml } from "smol-toml";
 import { z as z9 } from "zod/mini";
 var GeminiCliCommandFrontmatterSchema = z9.looseObject({
@@ -1617,7 +1568,7 @@ ${geminiFrontmatter.prompt}
     return new _GeminiCliCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: basename10(relativeFilePath),
+      relativeFilePath: basename9(relativeFilePath),
       fileContent,
       validate
     });
@@ -1639,7 +1590,7 @@ ${geminiFrontmatter.prompt}
 };
 
 // src/features/commands/opencode-command.ts
-import { basename as basename11, join as join12 } from "path";
+import { basename as basename10, join as join12 } from "path";
 import { optional as optional2, z as z10 } from "zod/mini";
 var OpenCodeCommandFrontmatterSchema = z10.looseObject({
   description: z10.string(),
@@ -1750,7 +1701,7 @@ var OpenCodeCommand = class _OpenCodeCommand extends ToolCommand {
     return new _OpenCodeCommand({
       baseDir,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath: basename11(relativeFilePath),
+      relativeFilePath: basename10(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -1765,7 +1716,7 @@ var OpenCodeCommand = class _OpenCodeCommand extends ToolCommand {
 };
 
 // src/features/commands/roo-command.ts
-import { basename as basename12, join as join13 } from "path";
+import { basename as basename11, join as join13 } from "path";
 import { optional as optional3, z as z11 } from "zod/mini";
 var RooCommandFrontmatterSchema = z11.looseObject({
   description: z11.string(),
@@ -1881,7 +1832,7 @@ var RooCommand = class _RooCommand extends ToolCommand {
     return new _RooCommand({
       baseDir,
       relativeDirPath: _RooCommand.getSettablePaths().relativeDirPath,
-      relativeFilePath: basename12(relativeFilePath),
+      relativeFilePath: basename11(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       fileContent,
@@ -2052,7 +2003,7 @@ var CommandsProcessor = class extends FeatureProcessor {
     );
     const rulesyncCommands = await Promise.all(
       rulesyncCommandPaths.map(
-        (path3) => RulesyncCommand.fromFile({ relativeFilePath: basename13(path3) })
+        (path3) => RulesyncCommand.fromFile({ relativeFilePath: basename12(path3) })
       )
     );
     logger.info(`Successfully loaded ${rulesyncCommands.length} rulesync commands`);
@@ -2074,7 +2025,7 @@ var CommandsProcessor = class extends FeatureProcessor {
       commandFilePaths.map(
         (path3) => factory.class.fromFile({
           baseDir: this.baseDir,
-          relativeFilePath: basename13(path3),
+          relativeFilePath: basename12(path3),
           global: this.global
         })
       )
@@ -2374,11 +2325,19 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
     const exists = await fileExists(filePath);
     const existingFileContent = exists ? await readFileContent(filePath) : "{}";
     const existingJsonValue = JSON.parse(existingFileContent);
+    const existingDenies = existingJsonValue.permissions?.deny ?? [];
+    const preservedDenies = existingDenies.filter((deny) => {
+      const isReadPattern = deny.startsWith("Read(") && deny.endsWith(")");
+      if (isReadPattern) {
+        return deniedValues.includes(deny);
+      }
+      return true;
+    });
     const jsonValue = {
       ...existingJsonValue,
       permissions: {
         ...existingJsonValue.permissions,
-        deny: uniq([...existingJsonValue.permissions?.deny ?? [], ...deniedValues].toSorted())
+        deny: uniq([...preservedDenies, ...deniedValues].toSorted())
       }
     };
     return new _ClaudecodeIgnore({
@@ -4282,9 +4241,9 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/features/rules/rules-processor.ts
-import { basename as basename21, join as join82 } from "path";
+import { basename as basename20, join as join82 } from "path";
 import { encode } from "@toon-format/toon";
-import { z as z33 } from "zod/mini";
+import { z as z34 } from "zod/mini";
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -4300,7 +4259,7 @@ import { z as z19 } from "zod/mini";
 import { join as join40 } from "path";
 
 // src/types/ai-dir.ts
-import path2, { basename as basename14, join as join39, relative as relative3, resolve as resolve4 } from "path";
+import path2, { basename as basename13, join as join39, relative as relative3, resolve as resolve4 } from "path";
 var AiDir = class {
   /**
    * @example "."
@@ -4397,7 +4356,7 @@ var AiDir = class {
     const dirPath = join39(baseDir, relativeDirPath, dirName);
     const glob = join39(dirPath, "**", "*");
     const filePaths = await findFilesByGlobs(glob, { type: "file" });
-    const filteredPaths = filePaths.filter((filePath) => basename14(filePath) !== excludeFileName);
+    const filteredPaths = filePaths.filter((filePath) => basename13(filePath) !== excludeFileName);
     const files = await Promise.all(
       filteredPaths.map(async (filePath) => {
         const fileBuffer = await readFileBuffer(filePath);
@@ -5024,7 +4983,7 @@ var GeminiCliSkill = class _GeminiCliSkill extends SimulatedSkill {
 };
 
 // src/features/skills/skills-processor.ts
-import { basename as basename15, join as join50 } from "path";
+import { basename as basename14, join as join50 } from "path";
 import { z as z23 } from "zod/mini";
 
 // src/types/dir-feature-processor.ts
@@ -5351,7 +5310,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
     const paths = RulesyncSkill.getSettablePaths();
     const rulesyncSkillsDirPath = join50(this.baseDir, paths.relativeDirPath);
     const dirPaths = await findFilesByGlobs(join50(rulesyncSkillsDirPath, "*"), { type: "dir" });
-    const dirNames = dirPaths.map((path3) => basename15(path3));
+    const dirNames = dirPaths.map((path3) => basename14(path3));
     const rulesyncSkills = await Promise.all(
       dirNames.map(
         (dirName) => RulesyncSkill.fromDir({ baseDir: this.baseDir, dirName, global: this.global })
@@ -5369,7 +5328,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
     const paths = factory.class.getSettablePaths({ global: this.global });
     const skillsDirPath = join50(this.baseDir, paths.relativeDirPath);
     const dirPaths = await findFilesByGlobs(join50(skillsDirPath, "*"), { type: "dir" });
-    const dirNames = dirPaths.map((path3) => basename15(path3));
+    const dirNames = dirPaths.map((path3) => basename14(path3));
     const toolSkills = await Promise.all(
       dirNames.map(
         (dirName) => factory.class.fromDir({
@@ -5422,7 +5381,7 @@ var SkillsProcessor = class extends DirFeatureProcessor {
 import { join as join52 } from "path";
 
 // src/features/subagents/simulated-subagent.ts
-import { basename as basename16, join as join51 } from "path";
+import { basename as basename15, join as join51 } from "path";
 import { z as z24 } from "zod/mini";
 
 // src/features/subagents/tool-subagent.ts
@@ -5541,7 +5500,7 @@ var SimulatedSubagent = class extends ToolSubagent {
     return {
       baseDir,
       relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: basename16(relativeFilePath),
+      relativeFilePath: basename15(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -5693,7 +5652,7 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 };
 
 // src/features/subagents/subagents-processor.ts
-import { basename as basename18, join as join60 } from "path";
+import { basename as basename17, join as join60 } from "path";
 import { z as z27 } from "zod/mini";
 
 // src/features/subagents/claudecode-subagent.ts
@@ -5701,7 +5660,7 @@ import { join as join59 } from "path";
 import { z as z26 } from "zod/mini";
 
 // src/features/subagents/rulesync-subagent.ts
-import { basename as basename17, join as join58 } from "path";
+import { basename as basename16, join as join58 } from "path";
 import { z as z25 } from "zod/mini";
 var RulesyncSubagentFrontmatterSchema = z25.looseObject({
   targets: RulesyncTargetsSchema,
@@ -5765,7 +5724,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
     if (!result.success) {
       throw new Error(`Invalid frontmatter in ${relativeFilePath}: ${formatError(result.error)}`);
     }
-    const filename = basename17(relativeFilePath);
+    const filename = basename16(relativeFilePath);
     return new _RulesyncSubagent({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().relativeDirPath,
@@ -6080,7 +6039,7 @@ var SubagentsProcessor = class extends FeatureProcessor {
       subagentFilePaths.map(
         (path3) => factory.class.fromFile({
           baseDir: this.baseDir,
-          relativeFilePath: basename18(path3),
+          relativeFilePath: basename17(path3),
           global: this.global
         })
       )
@@ -6119,7 +6078,7 @@ import { join as join63 } from "path";
 import { join as join62 } from "path";
 
 // src/features/rules/rulesync-rule.ts
-import { basename as basename19, join as join61 } from "path";
+import { basename as basename18, join as join61 } from "path";
 import { z as z28 } from "zod/mini";
 var RulesyncRuleFrontmatterSchema = z28.object({
   root: z28.optional(z28.optional(z28.boolean())),
@@ -6150,6 +6109,12 @@ var RulesyncRuleFrontmatterSchema = z28.object({
     z28.object({
       excludeAgent: z28.optional(z28.union([z28.literal("code-review"), z28.literal("coding-agent")]))
     })
+  ),
+  antigravity: z28.optional(
+    z28.looseObject({
+      trigger: z28.optional(z28.string()),
+      globs: z28.optional(z28.array(z28.string()))
+    })
   )
 });
 var RulesyncRule = class _RulesyncRule extends RulesyncFile {
@@ -6175,9 +6140,6 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
     return {
       recommended: {
         relativeDirPath: RULESYNC_RULES_RELATIVE_DIR_PATH
-      },
-      legacy: {
-        relativeDirPath: RULESYNC_RELATIVE_DIR_PATH
       }
     };
   }
@@ -6200,44 +6162,6 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       };
     }
   }
-  static async fromFileLegacy({
-    relativeFilePath,
-    validate = true
-  }) {
-    const legacyPath = join61(
-      process.cwd(),
-      this.getSettablePaths().legacy.relativeDirPath,
-      relativeFilePath
-    );
-    const recommendedPath = join61(
-      this.getSettablePaths().recommended.relativeDirPath,
-      relativeFilePath
-    );
-    logger.warn(`\u26A0\uFE0F  Using deprecated path "${legacyPath}". Please migrate to "${recommendedPath}"`);
-    const fileContent = await readFileContent(legacyPath);
-    const { frontmatter, body: content } = parseFrontmatter(fileContent);
-    const result = RulesyncRuleFrontmatterSchema.safeParse(frontmatter);
-    if (!result.success) {
-      throw new Error(`Invalid frontmatter in ${legacyPath}: ${formatError(result.error)}`);
-    }
-    const validatedFrontmatter = {
-      root: result.data.root ?? false,
-      targets: result.data.targets ?? ["*"],
-      description: result.data.description ?? "",
-      globs: result.data.globs ?? [],
-      agentsmd: result.data.agentsmd,
-      cursor: result.data.cursor
-    };
-    const filename = basename19(legacyPath);
-    return new _RulesyncRule({
-      baseDir: process.cwd(),
-      relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
-      relativeFilePath: filename,
-      frontmatter: validatedFrontmatter,
-      body: content.trim(),
-      validate
-    });
-  }
   static async fromFile({
     relativeFilePath,
     validate = true
@@ -6261,7 +6185,7 @@ var RulesyncRule = class _RulesyncRule extends RulesyncFile {
       agentsmd: result.data.agentsmd,
       cursor: result.data.cursor
     };
-    const filename = basename19(filePath);
+    const filename = basename18(filePath);
     return new _RulesyncRule({
       baseDir: process.cwd(),
       relativeDirPath: this.getSettablePaths().recommended.relativeDirPath,
@@ -6519,7 +6443,176 @@ var AmazonQCliRule = class _AmazonQCliRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 import { join as join65 } from "path";
+import { z as z29 } from "zod/mini";
+var AntigravityRuleFrontmatterSchema = z29.looseObject({
+  trigger: z29.optional(
+    z29.union([
+      z29.literal("always_on"),
+      z29.literal("glob"),
+      z29.literal("manual"),
+      z29.literal("model_decision"),
+      z29.string()
+      // accepts any string for forward compatibility
+    ])
+  ),
+  globs: z29.optional(z29.string()),
+  description: z29.optional(z29.string())
+});
+function parseGlobsString(globs) {
+  if (!globs) {
+    return [];
+  }
+  if (Array.isArray(globs)) {
+    return globs;
+  }
+  if (globs.trim() === "") {
+    return [];
+  }
+  return globs.split(",").map((g) => g.trim());
+}
+function stringifyGlobs(globs) {
+  if (!globs || globs.length === 0) {
+    return void 0;
+  }
+  return globs.join(",");
+}
+function normalizeStoredAntigravity(stored) {
+  if (!stored) {
+    return void 0;
+  }
+  const { globs, ...rest } = stored;
+  return {
+    ...rest,
+    globs: Array.isArray(globs) ? stringifyGlobs(globs) : globs
+  };
+}
+var globStrategy = {
+  canHandle: (trigger) => trigger === "glob",
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => {
+    const effectiveGlobsArray = normalized?.globs ? parseGlobsString(normalized.globs) : rulesyncFrontmatter.globs ?? [];
+    return {
+      ...normalized,
+      trigger: "glob",
+      globs: stringifyGlobs(effectiveGlobsArray)
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: parseGlobsString(frontmatter.globs),
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var manualStrategy = {
+  canHandle: (trigger) => trigger === "manual",
+  generateFrontmatter: (normalized) => ({
+    ...normalized,
+    trigger: "manual"
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: [],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var alwaysOnStrategy = {
+  canHandle: (trigger) => trigger === "always_on",
+  generateFrontmatter: (normalized) => ({
+    ...normalized,
+    trigger: "always_on"
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var modelDecisionStrategy = {
+  canHandle: (trigger) => trigger === "model_decision",
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => ({
+    ...normalized,
+    trigger: "model_decision",
+    description: rulesyncFrontmatter.description
+  }),
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: [],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var unknownStrategy = {
+  canHandle: (trigger) => trigger !== void 0,
+  generateFrontmatter: (normalized) => {
+    const trigger = typeof normalized?.trigger === "string" ? normalized.trigger : "manual";
+    return {
+      ...normalized,
+      trigger
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var inferenceStrategy = {
+  canHandle: (trigger) => trigger === void 0,
+  generateFrontmatter: (normalized, rulesyncFrontmatter) => {
+    const effectiveGlobsArray = normalized?.globs ? parseGlobsString(normalized.globs) : rulesyncFrontmatter.globs ?? [];
+    if (effectiveGlobsArray.length > 0 && !effectiveGlobsArray.includes("**/*") && !effectiveGlobsArray.includes("*")) {
+      return {
+        ...normalized,
+        trigger: "glob",
+        globs: stringifyGlobs(effectiveGlobsArray)
+      };
+    }
+    return {
+      ...normalized,
+      trigger: "always_on"
+    };
+  },
+  exportRulesyncData: ({ description, ...frontmatter }) => ({
+    globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
+    description: description || "",
+    antigravity: frontmatter
+  })
+};
+var STRATEGIES = [
+  globStrategy,
+  manualStrategy,
+  alwaysOnStrategy,
+  modelDecisionStrategy,
+  unknownStrategy,
+  inferenceStrategy
+];
 var AntigravityRule = class _AntigravityRule extends ToolRule {
+  frontmatter;
+  body;
+  /**
+   * Creates an AntigravityRule instance.
+   *
+   * @param params - Rule parameters including frontmatter and body
+   * @param params.frontmatter - Antigravity-specific frontmatter configuration
+   * @param params.body - The markdown body content (without frontmatter)
+   *
+   * Note: Files without frontmatter will default to always_on trigger during fromFile().
+   */
+  constructor({ frontmatter, body, ...rest }) {
+    if (rest.validate !== false) {
+      const result = AntigravityRuleFrontmatterSchema.safeParse(frontmatter);
+      if (!result.success) {
+        throw new Error(
+          `Invalid frontmatter in ${join65(rest.relativeDirPath, rest.relativeFilePath)}: ${formatError(result.error)}`
+        );
+      }
+    }
+    super({
+      ...rest,
+      // Ensure fileContent includes frontmatter when constructed directly
+      fileContent: stringifyFrontmatter(body, frontmatter)
+    });
+    this.frontmatter = frontmatter;
+    this.body = body;
+  }
   static getSettablePaths() {
     return {
       nonRoot: {
@@ -6532,36 +6625,121 @@ var AntigravityRule = class _AntigravityRule extends ToolRule {
     relativeFilePath,
     validate = true
   }) {
-    const fileContent = await readFileContent(
-      join65(baseDir, this.getSettablePaths().nonRoot.relativeDirPath, relativeFilePath)
+    const filePath = join65(
+      baseDir,
+      this.getSettablePaths().nonRoot.relativeDirPath,
+      relativeFilePath
     );
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body } = parseFrontmatter(fileContent);
+    let parsedFrontmatter;
+    if (validate) {
+      const result = AntigravityRuleFrontmatterSchema.safeParse(frontmatter);
+      if (result.success) {
+        parsedFrontmatter = result.data;
+      } else {
+        throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
+      }
+    } else {
+      parsedFrontmatter = frontmatter;
+    }
     return new _AntigravityRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
       relativeFilePath,
-      fileContent,
+      body,
+      frontmatter: parsedFrontmatter,
       validate,
       root: false
     });
   }
+  /**
+   * Converts a RulesyncRule to an AntigravityRule.
+   *
+   * Trigger inference:
+   * - If antigravity.trigger is set, it's preserved
+   * - If specific globs are set, infers "glob" trigger
+   * - Otherwise, infers "always_on" trigger
+   */
   static fromRulesyncRule({
     baseDir = process.cwd(),
     rulesyncRule,
     validate = true
   }) {
-    return new _AntigravityRule(
-      this.buildToolRuleParamsDefault({
-        baseDir,
-        rulesyncRule,
-        validate,
-        nonRootPath: this.getSettablePaths().nonRoot
-      })
-    );
+    const rulesyncFrontmatter = rulesyncRule.getFrontmatter();
+    const storedAntigravity = rulesyncFrontmatter.antigravity;
+    const normalized = normalizeStoredAntigravity(storedAntigravity);
+    const storedTrigger = storedAntigravity?.trigger;
+    const strategy = STRATEGIES.find((s) => s.canHandle(storedTrigger));
+    if (!strategy) {
+      throw new Error(`No strategy found for trigger: ${storedTrigger}`);
+    }
+    const frontmatter = strategy.generateFrontmatter(normalized, rulesyncFrontmatter);
+    const paths = this.getSettablePaths();
+    const kebabCaseFilename = toKebabCaseFilename(rulesyncRule.getRelativeFilePath());
+    return new _AntigravityRule({
+      baseDir,
+      relativeDirPath: paths.nonRoot.relativeDirPath,
+      relativeFilePath: kebabCaseFilename,
+      frontmatter,
+      body: rulesyncRule.getBody(),
+      validate,
+      root: false
+    });
   }
+  /**
+   * Converts this AntigravityRule to a RulesyncRule.
+   *
+   * The Antigravity configuration is preserved in the RulesyncRule's
+   * frontmatter.antigravity field for round-trip compatibility.
+   *
+   * Note: All Antigravity rules are treated as non-root (root: false),
+   * as they are all placed in the .agent/rules directory.
+   *
+   * @returns RulesyncRule instance with Antigravity config preserved
+   */
   toRulesyncRule() {
-    return this.toRulesyncRuleDefault();
+    const strategy = STRATEGIES.find((s) => s.canHandle(this.frontmatter.trigger));
+    let rulesyncData = {
+      globs: [],
+      description: "",
+      antigravity: this.frontmatter
+    };
+    if (strategy) {
+      rulesyncData = strategy.exportRulesyncData(this.frontmatter);
+    }
+    const antigravityForRulesync = {
+      ...rulesyncData.antigravity,
+      globs: this.frontmatter.globs ? parseGlobsString(this.frontmatter.globs) : void 0
+    };
+    return new RulesyncRule({
+      baseDir: process.cwd(),
+      relativeDirPath: RulesyncRule.getSettablePaths().recommended.relativeDirPath,
+      relativeFilePath: this.getRelativeFilePath(),
+      frontmatter: {
+        root: false,
+        targets: ["*"],
+        ...rulesyncData,
+        antigravity: antigravityForRulesync
+      },
+      // When converting back, we only want the body content
+      body: this.body
+    });
+  }
+  getBody() {
+    return this.body;
+  }
+  // Helper to access raw file content including frontmatter is `this.fileContent` (from ToolFile)
+  // But we might want `body` only for some operations?
+  // ToolFile.getFileContent() returns the whole string.
+  getFrontmatter() {
+    return this.frontmatter;
   }
   validate() {
+    const result = AntigravityRuleFrontmatterSchema.safeParse(this.frontmatter);
+    if (!result.success) {
+      return { success: false, error: new Error(formatError(result.error)) };
+    }
     return { success: true, error: null };
   }
   static isTargetedByRulesyncRule(rulesyncRule) {
@@ -6795,9 +6973,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 import { join as join69 } from "path";
-import { z as z29 } from "zod/mini";
-var ClaudecodeRuleFrontmatterSchema = z29.object({
-  paths: z29.optional(z29.string())
+import { z as z30 } from "zod/mini";
+var ClaudecodeRuleFrontmatterSchema = z30.object({
+  paths: z30.optional(z30.string())
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -6987,9 +7165,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 import { join as join70 } from "path";
-import { z as z30 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z30.object({
-  description: z30.string()
+import { z as z31 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z31.object({
+  description: z31.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths() {
@@ -7136,11 +7314,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 import { join as join72 } from "path";
-import { z as z31 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z31.object({
-  description: z31.optional(z31.string()),
-  applyTo: z31.optional(z31.string()),
-  excludeAgent: z31.optional(z31.union([z31.literal("code-review"), z31.literal("coding-agent")]))
+import { z as z32 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z32.object({
+  description: z32.optional(z32.string()),
+  applyTo: z32.optional(z32.string()),
+  excludeAgent: z32.optional(z32.union([z32.literal("code-review"), z32.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -7307,12 +7485,12 @@ var CopilotRule = class _CopilotRule extends ToolRule {
 };
 
 // src/features/rules/cursor-rule.ts
-import { basename as basename20, join as join73 } from "path";
-import { z as z32 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z32.object({
-  description: z32.optional(z32.string()),
-  globs: z32.optional(z32.string()),
-  alwaysApply: z32.optional(z32.boolean())
+import { basename as basename19, join as join73 } from "path";
+import { z as z33 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z33.object({
+  description: z33.optional(z33.string()),
+  globs: z33.optional(z33.string()),
+  alwaysApply: z33.optional(z33.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -7458,7 +7636,7 @@ var CursorRule = class _CursorRule extends ToolRule {
     return new _CursorRule({
       baseDir,
       relativeDirPath: this.getSettablePaths().nonRoot.relativeDirPath,
-      relativeFilePath: basename20(relativeFilePath),
+      relativeFilePath: basename19(relativeFilePath),
       frontmatter: result.data,
       body: content.trim(),
       validate
@@ -8030,7 +8208,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z33.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z34.enum(rulesProcessorToolTargets);
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -8394,7 +8572,7 @@ var RulesProcessor = class extends FeatureProcessor {
     const files = await findFilesByGlobs(join82(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md"));
     logger.debug(`Found ${files.length} rulesync files`);
     const rulesyncRules = await Promise.all(
-      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename21(file) }))
+      files.map((file) => RulesyncRule.fromFile({ relativeFilePath: basename20(file) }))
     );
     const rootRules = rulesyncRules.filter((rule) => rule.getFrontmatter().root);
     if (rootRules.length > 1) {
@@ -8411,13 +8589,6 @@ var RulesProcessor = class extends FeatureProcessor {
     }
     return rulesyncRules;
   }
-  async loadRulesyncFilesLegacy() {
-    const legacyFiles = await findFilesByGlobs(join82(RULESYNC_RELATIVE_DIR_PATH, "*.md"));
-    logger.debug(`Found ${legacyFiles.length} legacy rulesync files`);
-    return Promise.all(
-      legacyFiles.map((file) => RulesyncRule.fromFileLegacy({ relativeFilePath: basename21(file) }))
-    );
-  }
   /**
    * Implementation of abstract method from FeatureProcessor
    * Load tool-specific rule configurations and parse them into ToolRule instances
@@ -8443,7 +8614,7 @@ var RulesProcessor = class extends FeatureProcessor {
           rootFilePaths.map(
             (filePath) => factory.class.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename21(filePath),
+              relativeFilePath: basename20(filePath),
               global: this.global
             })
           )
@@ -8461,7 +8632,7 @@ var RulesProcessor = class extends FeatureProcessor {
           nonRootFilePaths.map(
             (filePath) => factory.class.fromFile({
               baseDir: this.baseDir,
-              relativeFilePath: basename21(filePath),
+              relativeFilePath: basename20(filePath),
               global: this.global
             })
           )
@@ -8649,10 +8820,7 @@ async function generateRules(config, options) {
         const oldToolFiles = await processor.loadToolFiles({ forDeletion: true });
         await processor.removeAiFiles(oldToolFiles);
       }
-      let rulesyncFiles = await processor.loadRulesyncFiles();
-      if (rulesyncFiles.length === 0) {
-        rulesyncFiles = await processor.loadRulesyncFilesLegacy();
-      }
+      const rulesyncFiles = await processor.loadRulesyncFiles();
       const toolFiles = await processor.convertRulesyncFilesToToolFiles(rulesyncFiles);
       const writtenCount = await processor.writeAiFiles(toolFiles);
       totalRulesOutputs += writtenCount;
@@ -9378,8 +9546,8 @@ Attention, again, you are just the planner, so though you can read any files and
 import { FastMCP } from "fastmcp";
 
 // src/mcp/commands.ts
-import { basename as basename22, join as join85 } from "path";
-import { z as z34 } from "zod/mini";
+import { basename as basename21, join as join85 } from "path";
+import { z as z35 } from "zod/mini";
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
@@ -9415,7 +9583,7 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename22(relativePathFromCwd);
+  const filename = basename21(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
@@ -9440,7 +9608,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename22(relativePathFromCwd);
+  const filename = basename21(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -9484,7 +9652,7 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename22(relativePathFromCwd);
+  const filename = basename21(relativePathFromCwd);
   const fullPath = join85(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
@@ -9498,17 +9666,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: z34.object({}),
-  getCommand: z34.object({
-    relativePathFromCwd: z34.string()
+  listCommands: z35.object({}),
+  getCommand: z35.object({
+    relativePathFromCwd: z35.string()
   }),
-  putCommand: z34.object({
-    relativePathFromCwd: z34.string(),
+  putCommand: z35.object({
+    relativePathFromCwd: z35.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: z34.string()
+    body: z35.string()
   }),
-  deleteCommand: z34.object({
-    relativePathFromCwd: z34.string()
+  deleteCommand: z35.object({
+    relativePathFromCwd: z35.string()
   })
 };
 var commandTools = {
@@ -9557,7 +9725,7 @@ var commandTools = {
 
 // src/mcp/ignore.ts
 import { join as join86 } from "path";
-import { z as z35 } from "zod/mini";
+import { z as z36 } from "zod/mini";
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = join86(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -9614,11 +9782,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: z35.object({}),
-  putIgnoreFile: z35.object({
-    content: z35.string()
+  getIgnoreFile: z36.object({}),
+  putIgnoreFile: z36.object({
+    content: z36.string()
   }),
-  deleteIgnoreFile: z35.object({})
+  deleteIgnoreFile: z36.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -9652,7 +9820,7 @@ var ignoreTools = {
 
 // src/mcp/mcp.ts
 import { join as join87 } from "path";
-import { z as z36 } from "zod/mini";
+import { z as z37 } from "zod/mini";
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   const config = await ConfigResolver.resolve({});
@@ -9742,11 +9910,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: z36.object({}),
-  putMcpFile: z36.object({
-    content: z36.string()
+  getMcpFile: z37.object({}),
+  putMcpFile: z37.object({
+    content: z37.string()
   }),
-  deleteMcpFile: z36.object({})
+  deleteMcpFile: z37.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -9779,8 +9947,8 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-import { basename as basename23, join as join88 } from "path";
-import { z as z37 } from "zod/mini";
+import { basename as basename22, join as join88 } from "path";
+import { z as z38 } from "zod/mini";
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
@@ -9817,7 +9985,7 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename23(relativePathFromCwd);
+  const filename = basename22(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
@@ -9843,7 +10011,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename23(relativePathFromCwd);
+  const filename = basename22(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -9885,7 +10053,7 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename23(relativePathFromCwd);
+  const filename = basename22(relativePathFromCwd);
   const fullPath = join88(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
@@ -9899,17 +10067,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: z37.object({}),
-  getRule: z37.object({
-    relativePathFromCwd: z37.string()
+  listRules: z38.object({}),
+  getRule: z38.object({
+    relativePathFromCwd: z38.string()
   }),
-  putRule: z37.object({
-    relativePathFromCwd: z37.string(),
+  putRule: z38.object({
+    relativePathFromCwd: z38.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: z37.string()
+    body: z38.string()
   }),
-  deleteRule: z37.object({
-    relativePathFromCwd: z37.string()
+  deleteRule: z38.object({
+    relativePathFromCwd: z38.string()
   })
 };
 var ruleTools = {
@@ -9957,8 +10125,8 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-import { basename as basename24, dirname as dirname2, join as join89 } from "path";
-import { z as z38 } from "zod/mini";
+import { basename as basename23, dirname as dirname2, join as join89 } from "path";
+import { z as z39 } from "zod/mini";
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
 function aiDirFileToMcpSkillFile(file) {
@@ -9974,7 +10142,7 @@ function mcpSkillFileToAiDirFile(file) {
   };
 }
 function extractDirName(relativeDirPathFromCwd) {
-  const dirName = basename24(relativeDirPathFromCwd);
+  const dirName = basename23(relativeDirPathFromCwd);
   if (!dirName) {
     throw new Error(`Invalid path: ${relativeDirPathFromCwd}`);
   }
@@ -9986,7 +10154,7 @@ async function listSkills() {
     const skillDirPaths = await findFilesByGlobs(join89(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
-        const dirName = basename24(dirPath);
+        const dirName = basename23(dirPath);
         if (!dirName) return null;
         try {
           const skill = await RulesyncSkill.fromDir({
@@ -10126,23 +10294,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = z38.object({
-  name: z38.string(),
-  body: z38.string()
+var McpSkillFileSchema = z39.object({
+  name: z39.string(),
+  body: z39.string()
 });
 var skillToolSchemas = {
-  listSkills: z38.object({}),
-  getSkill: z38.object({
-    relativeDirPathFromCwd: z38.string()
+  listSkills: z39.object({}),
+  getSkill: z39.object({
+    relativeDirPathFromCwd: z39.string()
   }),
-  putSkill: z38.object({
-    relativeDirPathFromCwd: z38.string(),
+  putSkill: z39.object({
+    relativeDirPathFromCwd: z39.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: z38.string(),
-    otherFiles: z38.optional(z38.array(McpSkillFileSchema))
+    body: z39.string(),
+    otherFiles: z39.optional(z39.array(McpSkillFileSchema))
   }),
-  deleteSkill: z38.object({
-    relativeDirPathFromCwd: z38.string()
+  deleteSkill: z39.object({
+    relativeDirPathFromCwd: z39.string()
   })
 };
 var skillTools = {
@@ -10191,8 +10359,8 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-import { basename as basename25, join as join90 } from "path";
-import { z as z39 } from "zod/mini";
+import { basename as basename24, join as join90 } from "path";
+import { z as z40 } from "zod/mini";
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
@@ -10231,7 +10399,7 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename25(relativePathFromCwd);
+  const filename = basename24(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
@@ -10257,7 +10425,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename25(relativePathFromCwd);
+  const filename = basename24(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -10299,7 +10467,7 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = basename25(relativePathFromCwd);
+  const filename = basename24(relativePathFromCwd);
   const fullPath = join90(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
@@ -10316,17 +10484,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: z39.object({}),
-  getSubagent: z39.object({
-    relativePathFromCwd: z39.string()
+  listSubagents: z40.object({}),
+  getSubagent: z40.object({
+    relativePathFromCwd: z40.string()
   }),
-  putSubagent: z39.object({
-    relativePathFromCwd: z39.string(),
+  putSubagent: z40.object({
+    relativePathFromCwd: z40.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: z39.string()
+    body: z40.string()
   }),
-  deleteSubagent: z39.object({
-    relativePathFromCwd: z39.string()
+  deleteSubagent: z40.object({
+    relativePathFromCwd: z40.string()
   })
 };
 var subagentTools = {
@@ -10410,7 +10578,7 @@ async function mcpCommand({ version }) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "3.33.0";
+var getVersion = () => "4.0.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();
@@ -10434,18 +10602,14 @@ var main = async () => {
     (value) => {
       return value.split(",").map((f) => f.trim());
     }
-  ).option("-V, --verbose", "Verbose output").option("-g, --global", "Import for global(user scope) configuration files").option(
-    "--experimental-global",
-    "Import for global(user scope) configuration files (deprecated: use --global instead)"
-  ).action(async (options) => {
+  ).option("-V, --verbose", "Verbose output").option("-g, --global", "Import for global(user scope) configuration files").action(async (options) => {
     try {
       await importCommand({
         targets: options.targets,
         features: options.features,
         verbose: options.verbose,
         configPath: options.config,
-        global: options.global,
-        experimentalGlobal: options.experimentalGlobal
+        global: options.global
       });
     } catch (error) {
       logger.error(formatError(error));
@@ -10484,15 +10648,6 @@ var main = async () => {
   ).option(
     "--simulate-skills",
     "Generate simulated skills. This feature is only available for copilot, cursor and codexcli."
-  ).option(
-    "--experimental-global",
-    "Generate for global(user scope) configuration files (deprecated: use --global instead)"
-  ).option(
-    "--experimental-simulate-commands",
-    "Generate simulated commands (deprecated: use --simulate-commands instead)"
-  ).option(
-    "--experimental-simulate-subagents",
-    "Generate simulated subagents (deprecated: use --simulate-subagents instead)"
   ).option(
     "--modular-mcp",
     "Generate modular-mcp configuration for context compression (experimental)"
@@ -10509,10 +10664,7 @@ var main = async () => {
         simulateCommands: options.simulateCommands,
         simulateSubagents: options.simulateSubagents,
         simulateSkills: options.simulateSkills,
-        modularMcp: options.modularMcp,
-        experimentalGlobal: options.experimentalGlobal,
-        experimentalSimulateCommands: options.experimentalSimulateCommands,
-        experimentalSimulateSubagents: options.experimentalSimulateSubagents
+        modularMcp: options.modularMcp
       });
     } catch (error) {
       logger.error(formatError(error));