rulesync 8.1.0 → 8.3.0

package/dist/cli/index.cjs

@@ -44,12 +44,13 @@ var FeaturesSchema = import_mini.z.array(FeatureSchema);
 var FeatureOptionsSchema = import_mini.z.record(import_mini.z.string(), import_mini.z.unknown());
 var FeatureValueSchema = import_mini.z.union([import_mini.z.boolean(), FeatureOptionsSchema]);
 var PerFeatureConfigSchema = import_mini.z.record(import_mini.z.string(), FeatureValueSchema);
+var PerTargetFeaturesValueSchema = import_mini.z.union([
+  import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)),
+  PerFeatureConfigSchema
+]);
 var RulesyncFeaturesSchema = import_mini.z.union([
   import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)),
-  import_mini.z.record(
-    import_mini.z.string(),
-    import_mini.z.union([import_mini.z.array(import_mini.z.enum(ALL_FEATURES_WITH_WILDCARD)), PerFeatureConfigSchema])
-  )
+  import_mini.z.record(import_mini.z.string(), PerTargetFeaturesValueSchema)
 ]);
 var isFeatureValueEnabled = (value) => {
   if (value === true) return true;
@@ -951,6 +952,14 @@ var ALL_TOOL_TARGETS_WITH_WILDCARD = [...ALL_TOOL_TARGETS, "*"];
 var ToolTargetSchema = import_mini3.z.enum(ALL_TOOL_TARGETS);
 var ToolTargetsSchema = import_mini3.z.array(ToolTargetSchema);
 var RulesyncTargetsSchema = import_mini3.z.array(import_mini3.z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD));
+var RulesyncConfigTargetsObjectSchema = import_mini3.z.record(import_mini3.z.string(), PerTargetFeaturesValueSchema);
+var RulesyncConfigTargetsSchema = import_mini3.z.union([
+  RulesyncTargetsSchema,
+  RulesyncConfigTargetsObjectSchema
+]);
+var isRulesyncConfigTargetsObject = (value) => {
+  return !Array.isArray(value);
+};
 
 // src/features/commands/rulesync-command.ts
 var RulesyncCommandFrontmatterSchema = import_mini4.z.looseObject({
@@ -19994,7 +20003,7 @@ var SourceEntrySchema = import_mini69.z.object({
 });
 var ConfigParamsSchema = import_mini69.z.object({
   baseDirs: import_mini69.z.array(import_mini69.z.string()),
-  targets: RulesyncTargetsSchema,
+  targets: RulesyncConfigTargetsSchema,
   features: RulesyncFeaturesSchema,
   verbose: import_mini69.z.boolean(),
   delete: import_mini69.z.boolean(),
@@ -20021,10 +20030,42 @@ var CONFLICTING_TARGET_PAIRS = [
   ["claudecode", "claudecode-legacy"]
 ];
 var LEGACY_TARGETS = ["augmentcode-legacy", "claudecode-legacy"];
+var assertTargetsFeaturesExclusive = ({
+  targets,
+  features
+}) => {
+  const targetsIsObject = targets !== void 0 && !Array.isArray(targets);
+  const featuresIsObject = features !== void 0 && !Array.isArray(features);
+  if (targetsIsObject && features !== void 0) {
+    throw new Error(
+      "Invalid config: when 'targets' is in object form, 'features' must be omitted. Declare per-target features inside the 'targets' object instead."
+    );
+  }
+  if (featuresIsObject && targets !== void 0) {
+    throw new Error(
+      "Invalid config: when 'features' is in object form, 'targets' must be omitted. Migrate to the 'targets' object form, e.g. `targets: { claudecode: [...] }`."
+    );
+  }
+};
+var assertTargetsOrFeaturesProvided = ({
+  targets,
+  features
+}) => {
+  if (targets === void 0 && features === void 0) {
+    throw new Error("Invalid config: at least one of 'targets' or 'features' must be provided.");
+  }
+};
 var Config = class _Config {
   baseDirs;
   targets;
   features;
+  /**
+   * Cached list of validated `ToolTarget` keys for the object form of
+   * `targets`. Populated in the constructor after `validateObjectFormTargetKeys`
+   * so `getTargets()` does not rebuild the `ALL_TOOL_TARGETS` set on every call.
+   * Undefined when `this.targets` is in array form.
+   */
+  objectFormTargetKeys;
   verbose;
   delete;
   global;
@@ -20052,13 +20093,19 @@ var Config = class _Config {
     check,
     sources
   }) {
-    this.validateConflictingTargets(targets);
+    assertTargetsFeaturesExclusive({ targets, features });
+    assertTargetsOrFeaturesProvided({ targets, features });
+    const resolvedTargets = targets ?? [];
+    const resolvedFeatures = features ?? [];
+    this.validateObjectFormTargetKeys(resolvedTargets);
+    this.validateConflictingTargets(resolvedTargets);
     if (dryRun && check) {
       throw new Error("--dry-run and --check cannot be used together");
     }
     this.baseDirs = baseDirs;
-    this.targets = targets;
-    this.features = features;
+    this.targets = resolvedTargets;
+    this.features = resolvedFeatures;
+    this.objectFormTargetKeys = isRulesyncConfigTargetsObject(resolvedTargets) ? _Config.filterValidToolTargets(Object.keys(resolvedTargets)) : void 0;
     this.verbose = verbose;
     this.delete = isDelete;
     this.global = global ?? false;
@@ -20071,11 +20118,37 @@ var Config = class _Config {
     this.check = check ?? false;
     this.sources = sources ?? [];
   }
+  /**
+   * Rejects unknown keys (and the special `*` key) in the object form of
+   * `targets`. For the array form this is already enforced at the Zod schema
+   * level via `z.enum(ALL_TOOL_TARGETS_WITH_WILDCARD)`; for the object form
+   * `z.record(z.string(), ...)` intentionally accepts any string key (to work
+   * around zod's `z.record(z.enum(...))` requiring ALL enum members), so
+   * runtime validation lives here instead.
+   */
+  validateObjectFormTargetKeys(targets) {
+    if (Array.isArray(targets)) return;
+    const validTargets = new Set(ALL_TOOL_TARGETS);
+    for (const key of Object.keys(targets)) {
+      if (key === "*") {
+        throw new Error(
+          "Invalid target '*' in object form: wildcard is only supported in the array form `targets: ['*']`. Per-target options cannot be attached to a wildcard."
+        );
+      }
+      if (!validTargets.has(key)) {
+        throw new Error(`Unknown target '${key}'. Valid targets: ${ALL_TOOL_TARGETS.join(", ")}.`);
+      }
+    }
+  }
   validateConflictingTargets(targets) {
+    const has = (target) => {
+      if (Array.isArray(targets)) {
+        return targets.includes(target);
+      }
+      return Object.prototype.hasOwnProperty.call(targets, target);
+    };
     for (const [target1, target2] of CONFLICTING_TARGET_PAIRS) {
-      const hasTarget1 = targets.includes(target1);
-      const hasTarget2 = targets.includes(target2);
-      if (hasTarget1 && hasTarget2) {
+      if (has(target1) && has(target2)) {
         throw new Error(
           `Conflicting targets: '${target1}' and '${target2}' cannot be used together. Please choose one.`
         );
@@ -20085,16 +20158,45 @@ var Config = class _Config {
   getBaseDirs() {
     return this.baseDirs;
   }
+  /**
+   * Filter an arbitrary string-key list down to the known `ToolTarget` set,
+   * skipping `*` (which is only meaningful as an array element, not a key).
+   */
+  static filterValidToolTargets(keys) {
+    const validTargets = new Set(ALL_TOOL_TARGETS);
+    const result = [];
+    for (const key of keys) {
+      if (key === "*") continue;
+      if (!validTargets.has(key)) continue;
+      result.push(key);
+    }
+    return result;
+  }
   getTargets() {
-    if (this.targets.includes("*")) {
+    if (this.objectFormTargetKeys !== void 0) {
+      return this.objectFormTargetKeys;
+    }
+    const arrayTargets = Array.isArray(this.targets) ? this.targets : [];
+    if (!Array.isArray(this.features)) {
+      return _Config.filterValidToolTargets(Object.keys(this.features));
+    }
+    if (arrayTargets.includes("*")) {
       return ALL_TOOL_TARGETS.filter(
         // eslint-disable-next-line no-type-assertion/no-type-assertion
         (target) => !LEGACY_TARGETS.includes(target)
       );
     }
-    return this.targets.filter((target) => target !== "*");
+    return arrayTargets.filter((target) => target !== "*");
   }
   getFeatures(target) {
+    if (isRulesyncConfigTargetsObject(this.targets)) {
+      if (target) {
+        const value = this.targets[target];
+        if (!value) return [];
+        return _Config.normalizeTargetFeatures(value);
+      }
+      return _Config.collectAllFeatures(Object.values(this.targets));
+    }
     if (!Array.isArray(this.features)) {
       const perTargetFeatures = this.features;
       if (target) {
@@ -20104,20 +20206,7 @@ var Config = class _Config {
         }
         return _Config.normalizeTargetFeatures(targetFeatures);
       }
-      const allFeatures = [];
-      for (const features of Object.values(perTargetFeatures)) {
-        if (!features) continue;
-        const normalized = _Config.normalizeTargetFeatures(features);
-        for (const feature of normalized) {
-          if (!allFeatures.includes(feature)) {
-            allFeatures.push(feature);
-          }
-        }
-        if (allFeatures.length === ALL_FEATURES.length) {
-          return allFeatures;
-        }
-      }
-      return allFeatures;
+      return _Config.collectAllFeatures(Object.values(perTargetFeatures));
     }
     if (this.features.includes("*")) {
       return [...ALL_FEATURES];
@@ -20145,23 +20234,40 @@ var Config = class _Config {
     }
     return enabled;
   }
+  /**
+   * Collect the union of features across all per-target values.
+   * Used when `getFeatures()` is called without a target in object mode.
+   */
+  static collectAllFeatures(values) {
+    const allFeatures = [];
+    for (const value of values) {
+      if (!value) continue;
+      const normalized = _Config.normalizeTargetFeatures(value);
+      for (const feature of normalized) {
+        if (!allFeatures.includes(feature)) {
+          allFeatures.push(feature);
+        }
+      }
+      if (allFeatures.length === ALL_FEATURES.length) {
+        return allFeatures;
+      }
+    }
+    return allFeatures;
+  }
   /**
    * Returns the per-feature options object for a given target/feature, if any.
    * Returns `undefined` when no per-feature options were provided or when the
    * feature is not enabled for the given target.
    */
   getFeatureOptions(target, feature) {
-    if (Array.isArray(this.features)) {
+    const value = isRulesyncConfigTargetsObject(this.targets) ? this.targets[target] : !Array.isArray(this.features) ? this.features[target] : void 0;
+    if (!value || Array.isArray(value)) {
       return void 0;
     }
-    const targetFeatures = this.features[target];
-    if (!targetFeatures || Array.isArray(targetFeatures)) {
-      return void 0;
-    }
-    const perFeature = targetFeatures;
-    const value = perFeature[feature];
-    if (value && typeof value === "object" && isFeatureValueEnabled(value)) {
-      return value;
+    const perFeature = value;
+    const featureValue = perFeature[feature];
+    if (featureValue && typeof featureValue === "object" && isFeatureValueEnabled(featureValue)) {
+      return featureValue;
     }
     return void 0;
   }
@@ -20169,6 +20275,13 @@ var Config = class _Config {
    * Check if per-target features configuration is being used.
    */
   hasPerTargetFeatures() {
+    return isRulesyncConfigTargetsObject(this.targets) || !Array.isArray(this.features);
+  }
+  /**
+   * Returns true if the deprecated object form under `features` is in use.
+   * Callers can use this to emit a migration warning.
+   */
+  hasDeprecatedFeaturesObjectForm() {
     return !Array.isArray(this.features);
   }
   getVerbose() {
@@ -20213,6 +20326,17 @@ var Config = class _Config {
   }
 };
 
+// src/config/deprecation-warnings.ts
+var deprecationWarningEmitted = false;
+var emitFeaturesObjectFormDeprecationWarning = () => {
+  if (deprecationWarningEmitted) return;
+  if (process.env.RULESYNC_SILENT_DEPRECATION) return;
+  deprecationWarningEmitted = true;
+  console.warn(
+    "[rulesync] DEPRECATED: 'features' object form is deprecated. Use the new 'targets' object form instead: `targets: { claudecode: { rules: true, ignore: { fileMode: 'local' } } }`. See https://github.com/dyoshikawa/rulesync/blob/main/docs/guide/configuration.md for the migration guide."
+  );
+};
+
 // src/config/config-resolver.ts
 var getDefaults = () => ({
   targets: ["agentsmd"],
@@ -20239,6 +20363,10 @@ var loadConfigFromFile = async (filePath) => {
   const jsonData = (0, import_jsonc_parser4.parse)(fileContent);
   const parsed = ConfigFileSchema.parse(jsonData);
   const { $schema: _schema, ...configParams } = parsed;
+  assertTargetsFeaturesExclusive({
+    targets: configParams.targets,
+    features: configParams.features
+  });
   return configParams;
 };
 var mergeConfigs = (baseConfig, localConfig) => {
@@ -20282,14 +20410,35 @@ var ConfigResolver = class {
     const localConfigPath = (0, import_node_path134.join)(configDir, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
     const localConfig = await loadConfigFromFile(localConfigPath);
     const configByFile = mergeConfigs(baseConfig, localConfig);
+    try {
+      assertTargetsFeaturesExclusive({
+        targets: configByFile.targets,
+        features: configByFile.features
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `${detail} (detected after merging '${validatedConfigPath}' with '${localConfigPath}' \u2014 the two files combined produce the invalid combination; remove the conflicting field from one of them).`,
+        { cause: error }
+      );
+    }
     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 resolvedGitignoreTargetsOnly = gitignoreTargetsOnly ?? configByFile.gitignoreTargetsOnly ?? getDefaults().gitignoreTargetsOnly;
+    const userProvidedFeatures = features ?? configByFile.features;
+    const userProvidedTargets = targets ?? configByFile.targets;
+    const targetsIsObject = userProvidedTargets !== void 0 && !Array.isArray(userProvidedTargets);
+    const featuresIsObject = userProvidedFeatures !== void 0 && !Array.isArray(userProvidedFeatures);
+    if (featuresIsObject) {
+      emitFeaturesObjectFormDeprecationWarning();
+    }
+    const resolvedFeatures = userProvidedFeatures ?? (targetsIsObject ? void 0 : getDefaults().features);
+    const resolvedTargets = userProvidedTargets ?? (featuresIsObject ? void 0 : getDefaults().targets);
     const configParams = {
-      targets: targets ?? configByFile.targets ?? getDefaults().targets,
-      features: features ?? configByFile.features ?? getDefaults().features,
+      targets: resolvedTargets,
+      features: resolvedFeatures,
       verbose: verbose ?? configByFile.verbose ?? getDefaults().verbose,
       delete: isDelete ?? configByFile.delete ?? getDefaults().delete,
       baseDirs: getBaseDirsInLightOfGlobal({
@@ -20324,11 +20473,11 @@ function getBaseDirsInLightOfGlobal({
 }
 
 // src/lib/generate.ts
-var import_node_path140 = require("path");
+var import_node_path141 = require("path");
 var import_es_toolkit5 = require("es-toolkit");
 
 // src/features/permissions/permissions-processor.ts
-var import_mini73 = require("zod/mini");
+var import_mini74 = require("zod/mini");
 
 // src/features/permissions/claudecode-permissions.ts
 var import_node_path136 = require("path");
@@ -20657,6 +20806,7 @@ function convertClaudeToRulesyncPermissions(params) {
 var import_node_path137 = require("path");
 var smolToml5 = __toESM(require("smol-toml"), 1);
 var RULESYNC_PROFILE_NAME = "rulesync";
+var RULESYNC_BASH_RULES_FILE_NAME = "rulesync.rules";
 var CodexcliPermissions = class _CodexcliPermissions extends ToolPermissions {
   static getSettablePaths(_options = {}) {
     return {
@@ -20746,6 +20896,22 @@ var CodexcliPermissions = class _CodexcliPermissions extends ToolPermissions {
     });
   }
 };
+var CodexcliRulesFile = class extends ToolFile {
+  validate() {
+    return { success: true, error: null };
+  }
+};
+function createCodexcliBashRulesFile({
+  baseDir = process.cwd(),
+  config
+}) {
+  return new CodexcliRulesFile({
+    baseDir,
+    relativeDirPath: (0, import_node_path137.join)(".codex", "rules"),
+    relativeFilePath: RULESYNC_BASH_RULES_FILE_NAME,
+    fileContent: buildCodexBashRulesContent(config)
+  });
+}
 function convertRulesyncToCodexProfile({
   config,
   logger: logger5
@@ -20854,6 +21020,46 @@ function mapReadAction(action) {
 function mapWriteAction(action) {
   return action === "allow" ? "write" : "none";
 }
+function buildCodexBashRulesContent(config) {
+  const bashRules = config.permission.bash ?? {};
+  const entries = Object.entries(bashRules);
+  const header = [
+    "# Generated by Rulesync from .rulesync/permissions.json (permission.bash)",
+    "# https://developers.openai.com/codex/rules"
+  ];
+  if (entries.length === 0) {
+    return [...header, "# No bash permission rules were configured."].join("\n");
+  }
+  const ruleBlocks = entries.map(([pattern, action]) => {
+    const tokens = toCommandPatternTokens(pattern);
+    if (tokens.length === 0) {
+      return null;
+    }
+    const serializedTokens = tokens.map((token) => JSON.stringify(token)).join(", ");
+    const decision = mapBashActionToDecision(action);
+    return [
+      "",
+      `# ${pattern}`,
+      "prefix_rule(",
+      `    pattern = [${serializedTokens}],`,
+      `    decision = ${JSON.stringify(decision)},`,
+      `    justification = ${JSON.stringify(`Generated from Rulesync permission.bash: ${pattern}`)},`,
+      ")"
+    ].join("\n");
+  }).filter((block) => block !== null);
+  if (ruleBlocks.length === 0) {
+    return [...header, "# No valid bash patterns were found."].join("\n");
+  }
+  return [...header, ...ruleBlocks].join("\n");
+}
+function toCommandPatternTokens(commandPattern) {
+  return commandPattern.trim().split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
+}
+function mapBashActionToDecision(action) {
+  if (action === "allow") return "allow";
+  if (action === "ask") return "prompt";
+  return "forbidden";
+}
 
 // src/features/permissions/geminicli-permissions.ts
 var import_node_path138 = require("path");
@@ -21019,16 +21225,200 @@ function parseGeminicliToolEntry({ entry }) {
   };
 }
 
-// src/features/permissions/opencode-permissions.ts
+// src/features/permissions/kiro-permissions.ts
 var import_node_path139 = require("path");
-var import_jsonc_parser5 = require("jsonc-parser");
 var import_mini72 = require("zod/mini");
-var OpencodePermissionSchema = import_mini72.z.union([
-  import_mini72.z.enum(["allow", "ask", "deny"]),
-  import_mini72.z.record(import_mini72.z.string(), import_mini72.z.enum(["allow", "ask", "deny"]))
+var KiroAgentSchema = import_mini72.z.looseObject({
+  allowedTools: import_mini72.z.optional(import_mini72.z.array(import_mini72.z.string())),
+  toolsSettings: import_mini72.z.optional(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.unknown()))
+});
+var UnknownRecordSchema = import_mini72.z.record(import_mini72.z.string(), import_mini72.z.unknown());
+var KiroPermissions = class _KiroPermissions extends ToolPermissions {
+  static getSettablePaths(_options = {}) {
+    return {
+      relativeDirPath: (0, import_node_path139.join)(".kiro", "agents"),
+      relativeFilePath: "default.json"
+    };
+  }
+  isDeletable() {
+    return false;
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true
+  }) {
+    const paths = this.getSettablePaths();
+    const filePath = (0, import_node_path139.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    return new _KiroPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    validate = true,
+    logger: logger5
+  }) {
+    const paths = this.getSettablePaths();
+    const filePath = (0, import_node_path139.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const existingContent = await readFileContentOrNull(filePath) ?? JSON.stringify({}, null, 2);
+    const parsedResult = KiroAgentSchema.safeParse(JSON.parse(existingContent));
+    if (!parsedResult.success) {
+      throw new Error(
+        `Failed to parse existing Kiro agent config at ${filePath}: ${formatError(parsedResult.error)}`
+      );
+    }
+    const config = rulesyncPermissions.getJson();
+    const next = buildKiroPermissionsFromRulesync({ config, logger: logger5, existing: parsedResult.data });
+    return new _KiroPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent: JSON.stringify(next, null, 2),
+      validate
+    });
+  }
+  toRulesyncPermissions() {
+    let parsed;
+    try {
+      parsed = KiroAgentSchema.parse(JSON.parse(this.getFileContent()));
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Kiro permissions content in ${(0, import_node_path139.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const permission = {};
+    const toolsSettings = parsed.toolsSettings ?? {};
+    const shellSettings = asRecord(toolsSettings.shell);
+    const shellAllow = asStringArray(shellSettings.allowedCommands);
+    const shellDeny = asStringArray(shellSettings.deniedCommands);
+    if (shellAllow.length > 0 || shellDeny.length > 0) {
+      permission.bash = {};
+      for (const pattern of shellAllow) permission.bash[pattern] = "allow";
+      for (const pattern of shellDeny) permission.bash[pattern] = "deny";
+    }
+    const readSettings = asRecord(toolsSettings.read);
+    const readAllow = asStringArray(readSettings.allowedPaths);
+    const readDeny = asStringArray(readSettings.deniedPaths);
+    if (readAllow.length > 0 || readDeny.length > 0) {
+      permission.read = {};
+      for (const pattern of readAllow) permission.read[pattern] = "allow";
+      for (const pattern of readDeny) permission.read[pattern] = "deny";
+    }
+    const writeSettings = asRecord(toolsSettings.write);
+    const writeAllow = asStringArray(writeSettings.allowedPaths);
+    const writeDeny = asStringArray(writeSettings.deniedPaths);
+    if (writeAllow.length > 0 || writeDeny.length > 0) {
+      permission.write = {};
+      for (const pattern of writeAllow) permission.write[pattern] = "allow";
+      for (const pattern of writeDeny) permission.write[pattern] = "deny";
+    }
+    const allowedTools = new Set(parsed.allowedTools ?? []);
+    if (allowedTools.has("web_fetch")) {
+      permission.webfetch = { "*": "allow" };
+    }
+    if (allowedTools.has("web_search")) {
+      permission.websearch = { "*": "allow" };
+    }
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify({ permission }, null, 2)
+    });
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _KiroPermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify({}, null, 2),
+      validate: false
+    });
+  }
+};
+function buildKiroPermissionsFromRulesync({
+  config,
+  logger: logger5,
+  existing
+}) {
+  const nextAllowedTools = new Set(existing.allowedTools ?? []);
+  const nextToolsSettings = { ...asRecord(existing.toolsSettings) };
+  const shell = {
+    allowedCommands: [],
+    deniedCommands: []
+  };
+  const read = {
+    allowedPaths: [],
+    deniedPaths: []
+  };
+  const write = {
+    allowedPaths: [],
+    deniedPaths: []
+  };
+  for (const [category, rules] of Object.entries(config.permission)) {
+    for (const [pattern, action] of Object.entries(rules)) {
+      if (action === "ask") {
+        logger5?.warn(`Kiro permissions do not support "ask". Skipping ${category}:${pattern}`);
+        continue;
+      }
+      if (category === "bash") {
+        (action === "allow" ? shell.allowedCommands : shell.deniedCommands).push(pattern);
+      } else if (category === "read") {
+        (action === "allow" ? read.allowedPaths : read.deniedPaths).push(pattern);
+      } else if (category === "edit" || category === "write") {
+        (action === "allow" ? write.allowedPaths : write.deniedPaths).push(pattern);
+      } else if (category === "webfetch" || category === "websearch") {
+        if (pattern !== "*") {
+          logger5?.warn(
+            `Kiro ${category} supports only wildcard (*) via allowedTools. Skipping rule: ${pattern}`
+          );
+          continue;
+        }
+        if (action === "allow")
+          nextAllowedTools.add(category === "webfetch" ? "web_fetch" : "web_search");
+      } else {
+        logger5?.warn(`Kiro permissions do not support category: ${category}. Skipping.`);
+      }
+    }
+  }
+  nextToolsSettings.shell = shell;
+  nextToolsSettings.read = read;
+  nextToolsSettings.write = write;
+  return {
+    ...existing,
+    allowedTools: [...nextAllowedTools].toSorted(),
+    toolsSettings: nextToolsSettings
+  };
+}
+function asRecord(value) {
+  const result = UnknownRecordSchema.safeParse(value);
+  return result.success ? result.data : {};
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
+// src/features/permissions/opencode-permissions.ts
+var import_node_path140 = require("path");
+var import_jsonc_parser5 = require("jsonc-parser");
+var import_mini73 = require("zod/mini");
+var OpencodePermissionSchema = import_mini73.z.union([
+  import_mini73.z.enum(["allow", "ask", "deny"]),
+  import_mini73.z.record(import_mini73.z.string(), import_mini73.z.enum(["allow", "ask", "deny"]))
 ]);
-var OpencodePermissionsConfigSchema = import_mini72.z.looseObject({
-  permission: import_mini72.z.optional(import_mini72.z.record(import_mini72.z.string(), OpencodePermissionSchema))
+var OpencodePermissionsConfigSchema = import_mini73.z.looseObject({
+  permission: import_mini73.z.optional(import_mini73.z.record(import_mini73.z.string(), OpencodePermissionSchema))
 });
 var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   json;
@@ -21045,7 +21435,7 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   static getSettablePaths({
     global = false
   } = {}) {
-    return global ? { relativeDirPath: (0, import_node_path139.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
+    return global ? { relativeDirPath: (0, import_node_path140.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
   }
   static async fromFile({
     baseDir = process.cwd(),
@@ -21053,9 +21443,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    const jsonDir = (0, import_node_path139.join)(baseDir, basePaths.relativeDirPath);
-    const jsoncPath = (0, import_node_path139.join)(jsonDir, "opencode.jsonc");
-    const jsonPath = (0, import_node_path139.join)(jsonDir, "opencode.json");
+    const jsonDir = (0, import_node_path140.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path140.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path140.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -21080,9 +21470,9 @@ var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
     global = false
   }) {
     const basePaths = _OpencodePermissions.getSettablePaths({ global });
-    const jsonDir = (0, import_node_path139.join)(baseDir, basePaths.relativeDirPath);
-    const jsoncPath = (0, import_node_path139.join)(jsonDir, "opencode.jsonc");
-    const jsonPath = (0, import_node_path139.join)(jsonDir, "opencode.json");
+    const jsonDir = (0, import_node_path140.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path140.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path140.join)(jsonDir, "opencode.json");
     let fileContent = await readFileContentOrNull(jsoncPath);
     let relativeFilePath = "opencode.jsonc";
     if (!fileContent) {
@@ -21156,9 +21546,10 @@ var permissionsProcessorToolTargetTuple = [
   "claudecode",
   "codexcli",
   "geminicli",
+  "kiro",
   "opencode"
 ];
-var PermissionsProcessorToolTargetSchema = import_mini73.z.enum(permissionsProcessorToolTargetTuple);
+var PermissionsProcessorToolTargetSchema = import_mini74.z.enum(permissionsProcessorToolTargetTuple);
 var toolPermissionsFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -21166,7 +21557,7 @@ var toolPermissionsFactories = /* @__PURE__ */ new Map([
       class: ClaudecodePermissions,
       meta: {
         supportsProject: true,
-        supportsGlobal: false,
+        supportsGlobal: true,
         supportsImport: true
       }
     }
@@ -21193,6 +21584,17 @@ var toolPermissionsFactories = /* @__PURE__ */ new Map([
       }
     }
   ],
+  [
+    "kiro",
+    {
+      class: KiroPermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: false,
+        supportsImport: true
+      }
+    }
+  ],
   [
     "opencode",
     {
@@ -21288,7 +21690,14 @@ var PermissionsProcessor = class extends FeatureProcessor {
       logger: this.logger,
       global: this.global
     });
-    return [toolPermissions];
+    if (this.toolTarget !== "codexcli") {
+      return [toolPermissions];
+    }
+    const bashRulesFile = createCodexcliBashRulesFile({
+      baseDir: this.baseDir,
+      config: rulesyncPermissions.getJson()
+    });
+    return [toolPermissions, bashRulesFile];
   }
   async convertToolFilesToRulesyncFiles(toolFiles) {
     const permissions = toolFiles.filter((f) => f instanceof ToolPermissions);
@@ -21375,7 +21784,7 @@ function warnUnsupportedTargets(params) {
   }
 }
 async function checkRulesyncDirExists(params) {
-  return fileExists((0, import_node_path140.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
+  return fileExists((0, import_node_path141.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
 }
 async function generate(params) {
   const { config, logger: logger5 } = params;
@@ -21845,7 +22254,7 @@ async function generateCommand(logger5, options) {
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_path141 = require("path");
+var import_node_path142 = require("path");
 
 // src/cli/commands/gitignore-entries.ts
 var normalizeGitignoreEntryTargets = (target) => {
@@ -22189,7 +22598,7 @@ var removeExistingRulesyncEntries = (content) => {
   return result;
 };
 var gitignoreCommand = async (logger5, options) => {
-  const gitignorePath = (0, import_node_path141.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path142.join)(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
@@ -22510,6 +22919,12 @@ async function importCommand(logger5, options) {
   if (!options.targets) {
     throw new CLIError("No tools found in --targets", ErrorCodes.IMPORT_FAILED);
   }
+  if (!Array.isArray(options.targets)) {
+    throw new CLIError(
+      "--targets object form is not supported on the command line",
+      ErrorCodes.IMPORT_FAILED
+    );
+  }
   if (options.targets.length > 1) {
     throw new CLIError("Only one tool can be imported at a time", ErrorCodes.IMPORT_FAILED);
   }
@@ -22550,7 +22965,7 @@ async function importCommand(logger5, options) {
 }
 
 // src/lib/init.ts
-var import_node_path142 = require("path");
+var import_node_path143 = require("path");
 async function init() {
   const sampleFiles = await createSampleFiles();
   const configFile = await createConfigFile();
@@ -22743,27 +23158,27 @@ Keep the summary concise and ready to reuse in future tasks.`
   await ensureDir(subagentPaths.relativeDirPath);
   await ensureDir(skillPaths.relativeDirPath);
   await ensureDir(ignorePaths.recommended.relativeDirPath);
-  const ruleFilepath = (0, import_node_path142.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = (0, import_node_path143.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   results.push(await writeIfNotExists(ruleFilepath, sampleRuleFile.content));
-  const mcpFilepath = (0, import_node_path142.join)(
+  const mcpFilepath = (0, import_node_path143.join)(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(mcpFilepath, sampleMcpFile.content));
-  const commandFilepath = (0, import_node_path142.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = (0, import_node_path143.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
   results.push(await writeIfNotExists(commandFilepath, sampleCommandFile.content));
-  const subagentFilepath = (0, import_node_path142.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = (0, import_node_path143.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   results.push(await writeIfNotExists(subagentFilepath, sampleSubagentFile.content));
-  const skillDirPath = (0, import_node_path142.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
+  const skillDirPath = (0, import_node_path143.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
   await ensureDir(skillDirPath);
-  const skillFilepath = (0, import_node_path142.join)(skillDirPath, SKILL_FILE_NAME);
+  const skillFilepath = (0, import_node_path143.join)(skillDirPath, SKILL_FILE_NAME);
   results.push(await writeIfNotExists(skillFilepath, sampleSkillFile.content));
-  const ignoreFilepath = (0, import_node_path142.join)(
+  const ignoreFilepath = (0, import_node_path143.join)(
     ignorePaths.recommended.relativeDirPath,
     ignorePaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(ignoreFilepath, sampleIgnoreFile.content));
-  const hooksFilepath = (0, import_node_path142.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
+  const hooksFilepath = (0, import_node_path143.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
   results.push(await writeIfNotExists(hooksFilepath, sampleHooksFile.content));
   return results;
 }
@@ -22811,12 +23226,12 @@ async function initCommand(logger5) {
 }
 
 // src/lib/sources.ts
-var import_node_path145 = require("path");
+var import_node_path146 = require("path");
 var import_promise2 = require("es-toolkit/promise");
 
 // src/lib/git-client.ts
 var import_node_child_process = require("child_process");
-var import_node_path143 = require("path");
+var import_node_path144 = require("path");
 var import_node_util2 = require("util");
 var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process.execFile);
 var GIT_TIMEOUT_MS = 6e4;
@@ -22904,7 +23319,7 @@ async function fetchSkillFiles(params) {
   const { url, ref, skillsPath, logger: logger5 } = params;
   validateGitUrl(url, { logger: logger5 });
   validateRef(ref);
-  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path143.isAbsolute)(skillsPath)) {
+  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path144.isAbsolute)(skillsPath)) {
     throw new GitClientError(
       `Invalid skillsPath "${skillsPath}": must be a relative path without ".."`
     );
@@ -22938,7 +23353,7 @@ async function fetchSkillFiles(params) {
       timeout: GIT_TIMEOUT_MS
     });
     await execFileAsync("git", ["-C", tmpDir, "checkout"], { timeout: GIT_TIMEOUT_MS });
-    const skillsDir = (0, import_node_path143.join)(tmpDir, skillsPath);
+    const skillsDir = (0, import_node_path144.join)(tmpDir, skillsPath);
     if (!await directoryExists(skillsDir)) return [];
     return await walkDirectory(skillsDir, skillsDir, 0, { totalFiles: 0, totalSize: 0 }, logger5);
   } catch (error) {
@@ -22960,7 +23375,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
   const results = [];
   for (const name of await listDirectoryFiles(dir)) {
     if (name === ".git") continue;
-    const fullPath = (0, import_node_path143.join)(dir, name);
+    const fullPath = (0, import_node_path144.join)(dir, name);
     if (await isSymlink(fullPath)) {
       logger5?.warn(`Skipping symlink "${fullPath}".`);
       continue;
@@ -22988,7 +23403,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
         );
       }
       const content = await readFileContent(fullPath);
-      results.push({ relativePath: (0, import_node_path143.relative)(baseDir, fullPath), content, size });
+      results.push({ relativePath: (0, import_node_path144.relative)(baseDir, fullPath), content, size });
     }
   }
   return results;
@@ -22996,28 +23411,28 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
 
 // src/lib/sources-lock.ts
 var import_node_crypto = require("crypto");
-var import_node_path144 = require("path");
-var import_mini74 = require("zod/mini");
+var import_node_path145 = require("path");
+var import_mini75 = require("zod/mini");
 var LOCKFILE_VERSION = 1;
-var LockedSkillSchema = import_mini74.z.object({
-  integrity: import_mini74.z.string()
+var LockedSkillSchema = import_mini75.z.object({
+  integrity: import_mini75.z.string()
 });
-var LockedSourceSchema = import_mini74.z.object({
-  requestedRef: (0, import_mini74.optional)(import_mini74.z.string()),
-  resolvedRef: import_mini74.z.string().check((0, import_mini74.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
-  resolvedAt: (0, import_mini74.optional)(import_mini74.z.string()),
-  skills: import_mini74.z.record(import_mini74.z.string(), LockedSkillSchema)
+var LockedSourceSchema = import_mini75.z.object({
+  requestedRef: (0, import_mini75.optional)(import_mini75.z.string()),
+  resolvedRef: import_mini75.z.string().check((0, import_mini75.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
+  resolvedAt: (0, import_mini75.optional)(import_mini75.z.string()),
+  skills: import_mini75.z.record(import_mini75.z.string(), LockedSkillSchema)
 });
-var SourcesLockSchema = import_mini74.z.object({
-  lockfileVersion: import_mini74.z.number(),
-  sources: import_mini74.z.record(import_mini74.z.string(), LockedSourceSchema)
+var SourcesLockSchema = import_mini75.z.object({
+  lockfileVersion: import_mini75.z.number(),
+  sources: import_mini75.z.record(import_mini75.z.string(), LockedSourceSchema)
 });
-var LegacyLockedSourceSchema = import_mini74.z.object({
-  resolvedRef: import_mini74.z.string(),
-  skills: import_mini74.z.array(import_mini74.z.string())
+var LegacyLockedSourceSchema = import_mini75.z.object({
+  resolvedRef: import_mini75.z.string(),
+  skills: import_mini75.z.array(import_mini75.z.string())
 });
-var LegacySourcesLockSchema = import_mini74.z.object({
-  sources: import_mini74.z.record(import_mini74.z.string(), LegacyLockedSourceSchema)
+var LegacySourcesLockSchema = import_mini75.z.object({
+  sources: import_mini75.z.record(import_mini75.z.string(), LegacyLockedSourceSchema)
 });
 function migrateLegacyLock(params) {
   const { legacy, logger: logger5 } = params;
@@ -23042,7 +23457,7 @@ function createEmptyLock() {
 }
 async function readLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path145.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   if (!await fileExists(lockPath)) {
     logger5.debug("No sources lockfile found, starting fresh.");
     return createEmptyLock();
@@ -23071,7 +23486,7 @@ async function readLockFile(params) {
 }
 async function writeLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path144.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path145.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   const content = JSON.stringify(params.lock, null, 2) + "\n";
   await writeFileContent(lockPath, content);
   logger5.debug(`Wrote sources lockfile to ${lockPath}`);
@@ -23245,7 +23660,7 @@ function logGitClientHints(params) {
 async function checkLockedSkillsExist(curatedDir, skillNames) {
   if (skillNames.length === 0) return true;
   for (const name of skillNames) {
-    if (!await directoryExists((0, import_node_path145.join)(curatedDir, name))) {
+    if (!await directoryExists((0, import_node_path146.join)(curatedDir, name))) {
       return false;
     }
   }
@@ -23253,10 +23668,10 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
 }
 async function cleanPreviousCuratedSkills(params) {
   const { curatedDir, lockedSkillNames, logger: logger5 } = params;
-  const resolvedCuratedDir = (0, import_node_path145.resolve)(curatedDir);
+  const resolvedCuratedDir = (0, import_node_path146.resolve)(curatedDir);
   for (const prevSkill of lockedSkillNames) {
-    const prevDir = (0, import_node_path145.join)(curatedDir, prevSkill);
-    if (!(0, import_node_path145.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path145.sep)) {
+    const prevDir = (0, import_node_path146.join)(curatedDir, prevSkill);
+    if (!(0, import_node_path146.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path146.sep)) {
       logger5.warn(
         `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
       );
@@ -23295,9 +23710,9 @@ async function writeSkillAndComputeIntegrity(params) {
   for (const file of files) {
     checkPathTraversal({
       relativePath: file.relativePath,
-      intendedRootDir: (0, import_node_path145.join)(curatedDir, skillName)
+      intendedRootDir: (0, import_node_path146.join)(curatedDir, skillName)
     });
-    await writeFileContent((0, import_node_path145.join)(curatedDir, skillName, file.relativePath), file.content);
+    await writeFileContent((0, import_node_path146.join)(curatedDir, skillName, file.relativePath), file.content);
     written.push({ path: file.relativePath, content: file.content });
   }
   const integrity = computeSkillIntegrity(written);
@@ -23374,7 +23789,7 @@ async function fetchSource(params) {
     ref = resolvedSha;
     logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
   }
-  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path146.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
     if (allExist) {
@@ -23499,7 +23914,7 @@ async function fetchSourceViaGit(params) {
     requestedRef = def.ref;
     resolvedSha = def.sha;
   }
-  const curatedDir = (0, import_node_path145.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path146.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     if (await checkLockedSkillsExist(curatedDir, lockedSkillNames)) {
       return { skillCount: 0, fetchedSkillNames: lockedSkillNames, updatedLock: lock };
@@ -23615,11 +24030,11 @@ async function installCommand(logger5, options) {
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini83 = require("zod/mini");
+var import_mini84 = require("zod/mini");
 
 // src/mcp/commands.ts
-var import_node_path146 = require("path");
-var import_mini75 = require("zod/mini");
+var import_node_path147 = require("path");
+var import_mini76 = require("zod/mini");
 
 // src/utils/logger.ts
 var BaseLogger = class {
@@ -23770,7 +24185,7 @@ var logger = new ConsoleLogger({ verbose: false, silent: true });
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23786,7 +24201,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23808,13 +24223,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -23833,7 +24248,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -23843,7 +24258,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(
@@ -23860,11 +24275,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -23879,12 +24294,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path146.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path147.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -23893,23 +24308,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini75.z.object({}),
-  getCommand: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string()
+  listCommands: import_mini76.z.object({}),
+  getCommand: import_mini76.z.object({
+    relativePathFromCwd: import_mini76.z.string()
   }),
-  putCommand: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string(),
+  putCommand: import_mini76.z.object({
+    relativePathFromCwd: import_mini76.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini75.z.string()
+    body: import_mini76.z.string()
   }),
-  deleteCommand: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string()
+  deleteCommand: import_mini76.z.object({
+    relativePathFromCwd: import_mini76.z.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${(0, import_node_path146.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${(0, import_node_path147.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -23951,15 +24366,15 @@ var commandTools = {
 };
 
 // src/mcp/generate.ts
-var import_mini76 = require("zod/mini");
-var generateOptionsSchema = import_mini76.z.object({
-  targets: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string())),
-  features: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string())),
-  delete: import_mini76.z.optional(import_mini76.z.boolean()),
-  global: import_mini76.z.optional(import_mini76.z.boolean()),
-  simulateCommands: import_mini76.z.optional(import_mini76.z.boolean()),
-  simulateSubagents: import_mini76.z.optional(import_mini76.z.boolean()),
-  simulateSkills: import_mini76.z.optional(import_mini76.z.boolean())
+var import_mini77 = require("zod/mini");
+var generateOptionsSchema = import_mini77.z.object({
+  targets: import_mini77.z.optional(import_mini77.z.array(import_mini77.z.string())),
+  features: import_mini77.z.optional(import_mini77.z.array(import_mini77.z.string())),
+  delete: import_mini77.z.optional(import_mini77.z.boolean()),
+  global: import_mini77.z.optional(import_mini77.z.boolean()),
+  simulateCommands: import_mini77.z.optional(import_mini77.z.boolean()),
+  simulateSubagents: import_mini77.z.optional(import_mini77.z.boolean()),
+  simulateSkills: import_mini77.z.optional(import_mini77.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -24038,11 +24453,11 @@ var generateTools = {
 };
 
 // src/mcp/ignore.ts
-var import_node_path147 = require("path");
-var import_mini77 = require("zod/mini");
+var import_node_path148 = require("path");
+var import_mini78 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -24059,7 +24474,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -24083,8 +24498,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const aiignorePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
-  const legacyIgnorePath = (0, import_node_path147.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const aiignorePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = (0, import_node_path148.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -24102,11 +24517,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini77.z.object({}),
-  putIgnoreFile: import_mini77.z.object({
-    content: import_mini77.z.string()
+  getIgnoreFile: import_mini78.z.object({}),
+  putIgnoreFile: import_mini78.z.object({
+    content: import_mini78.z.string()
   }),
-  deleteIgnoreFile: import_mini77.z.object({})
+  deleteIgnoreFile: import_mini78.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -24139,11 +24554,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-var import_mini78 = require("zod/mini");
-var importOptionsSchema = import_mini78.z.object({
-  target: import_mini78.z.string(),
-  features: import_mini78.z.optional(import_mini78.z.array(import_mini78.z.string())),
-  global: import_mini78.z.optional(import_mini78.z.boolean())
+var import_mini79 = require("zod/mini");
+var importOptionsSchema = import_mini79.z.object({
+  target: import_mini79.z.string(),
+  features: import_mini79.z.optional(import_mini79.z.array(import_mini79.z.string())),
+  global: import_mini79.z.optional(import_mini79.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -24214,15 +24629,15 @@ var importTools = {
 };
 
 // src/mcp/mcp.ts
-var import_node_path148 = require("path");
-var import_mini79 = require("zod/mini");
+var import_node_path149 = require("path");
+var import_mini80 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
     const rulesyncMcp = await RulesyncMcp.fromFile({
       validate: true
     });
-    const relativePathFromCwd = (0, import_node_path148.join)(
+    const relativePathFromCwd = (0, import_node_path149.join)(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -24260,7 +24675,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = (0, import_node_path148.join)(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = (0, import_node_path149.join)(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -24268,9 +24683,9 @@ async function putMcpFile({ content }) {
       fileContent: content,
       validate: true
     });
-    await ensureDir((0, import_node_path148.join)(baseDir, relativeDirPath));
+    await ensureDir((0, import_node_path149.join)(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = (0, import_node_path148.join)(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = (0, import_node_path149.join)(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -24288,15 +24703,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = (0, import_node_path148.join)(
+    const recommendedPath = (0, import_node_path149.join)(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = (0, import_node_path148.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = (0, import_node_path149.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = (0, import_node_path148.join)(
+    const relativePathFromCwd = (0, import_node_path149.join)(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -24313,11 +24728,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini79.z.object({}),
-  putMcpFile: import_mini79.z.object({
-    content: import_mini79.z.string()
+  getMcpFile: import_mini80.z.object({}),
+  putMcpFile: import_mini80.z.object({
+    content: import_mini80.z.string()
   }),
-  deleteMcpFile: import_mini79.z.object({})
+  deleteMcpFile: import_mini80.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -24350,13 +24765,13 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-var import_node_path149 = require("path");
-var import_mini80 = require("zod/mini");
+var import_node_path150 = require("path");
+var import_mini81 = require("zod/mini");
 var logger2 = new ConsoleLogger({ verbose: false, silent: true });
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
 async function listRules() {
-  const rulesDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -24369,7 +24784,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -24391,14 +24806,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path150.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -24417,7 +24832,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path150.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -24427,7 +24842,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(
@@ -24442,11 +24857,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -24461,12 +24876,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path149.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path150.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -24475,23 +24890,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini80.z.object({}),
-  getRule: import_mini80.z.object({
-    relativePathFromCwd: import_mini80.z.string()
+  listRules: import_mini81.z.object({}),
+  getRule: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string()
   }),
-  putRule: import_mini80.z.object({
-    relativePathFromCwd: import_mini80.z.string(),
+  putRule: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini80.z.string()
+    body: import_mini81.z.string()
   }),
-  deleteRule: import_mini80.z.object({
-    relativePathFromCwd: import_mini80.z.string()
+  deleteRule: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${(0, import_node_path149.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${(0, import_node_path150.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -24533,8 +24948,8 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-var import_node_path150 = require("path");
-var import_mini81 = require("zod/mini");
+var import_node_path151 = require("path");
+var import_mini82 = require("zod/mini");
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -24551,19 +24966,19 @@ function mcpSkillFileToAiDirFile(file) {
   };
 }
 function extractDirName(relativeDirPathFromCwd) {
-  const dirName = (0, import_node_path150.basename)(relativeDirPathFromCwd);
+  const dirName = (0, import_node_path151.basename)(relativeDirPathFromCwd);
   if (!dirName) {
     throw new Error(`Invalid path: ${relativeDirPathFromCwd}`);
   }
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs((0, import_node_path150.join)(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs((0, import_node_path151.join)(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
-        const dirName = (0, import_node_path150.basename)(dirPath);
+        const dirName = (0, import_node_path151.basename)(dirPath);
         if (!dirName) return null;
         try {
           const skill = await RulesyncSkill.fromDir({
@@ -24571,7 +24986,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -24599,7 +25014,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24633,7 +25048,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(
@@ -24650,9 +25065,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = (0, import_node_path150.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = (0, import_node_path151.join)(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -24660,15 +25075,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      const filePath = (0, import_node_path150.join)(skillDirPath, file.name);
-      const fileDir = (0, import_node_path150.join)(skillDirPath, (0, import_node_path150.dirname)(file.name));
+      const filePath = (0, import_node_path151.join)(skillDirPath, file.name);
+      const fileDir = (0, import_node_path151.join)(skillDirPath, (0, import_node_path151.dirname)(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -24690,13 +25105,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = (0, import_node_path150.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: (0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -24707,29 +25122,29 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini81.z.object({
-  name: import_mini81.z.string(),
-  body: import_mini81.z.string()
+var McpSkillFileSchema = import_mini82.z.object({
+  name: import_mini82.z.string(),
+  body: import_mini82.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini81.z.object({}),
-  getSkill: import_mini81.z.object({
-    relativeDirPathFromCwd: import_mini81.z.string()
+  listSkills: import_mini82.z.object({}),
+  getSkill: import_mini82.z.object({
+    relativeDirPathFromCwd: import_mini82.z.string()
   }),
-  putSkill: import_mini81.z.object({
-    relativeDirPathFromCwd: import_mini81.z.string(),
+  putSkill: import_mini82.z.object({
+    relativeDirPathFromCwd: import_mini82.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini81.z.string(),
-    otherFiles: import_mini81.z.optional(import_mini81.z.array(McpSkillFileSchema))
+    body: import_mini82.z.string(),
+    otherFiles: import_mini82.z.optional(import_mini82.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini81.z.object({
-    relativeDirPathFromCwd: import_mini81.z.string()
+  deleteSkill: import_mini82.z.object({
+    relativeDirPathFromCwd: import_mini82.z.string()
   })
 };
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${(0, import_node_path150.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${(0, import_node_path151.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -24772,13 +25187,13 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-var import_node_path151 = require("path");
-var import_mini82 = require("zod/mini");
+var import_node_path152 = require("path");
+var import_mini83 = require("zod/mini");
 var logger4 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
 async function listSubagents() {
-  const subagentsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = (0, import_node_path152.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -24791,7 +25206,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -24815,14 +25230,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path152.basename)(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -24841,7 +25256,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path152.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -24851,7 +25266,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(
@@ -24866,11 +25281,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = (0, import_node_path152.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -24885,12 +25300,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path151.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path151.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path152.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path152.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -24902,23 +25317,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini82.z.object({}),
-  getSubagent: import_mini82.z.object({
-    relativePathFromCwd: import_mini82.z.string()
+  listSubagents: import_mini83.z.object({}),
+  getSubagent: import_mini83.z.object({
+    relativePathFromCwd: import_mini83.z.string()
   }),
-  putSubagent: import_mini82.z.object({
-    relativePathFromCwd: import_mini82.z.string(),
+  putSubagent: import_mini83.z.object({
+    relativePathFromCwd: import_mini83.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini82.z.string()
+    body: import_mini83.z.string()
   }),
-  deleteSubagent: import_mini82.z.object({
-    relativePathFromCwd: import_mini82.z.string()
+  deleteSubagent: import_mini83.z.object({
+    relativePathFromCwd: import_mini83.z.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${(0, import_node_path151.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${(0, import_node_path152.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -24960,7 +25375,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini83.z.enum([
+var rulesyncFeatureSchema = import_mini84.z.enum([
   "rule",
   "command",
   "subagent",
@@ -24970,21 +25385,21 @@ var rulesyncFeatureSchema = import_mini83.z.enum([
   "generate",
   "import"
 ]);
-var rulesyncOperationSchema = import_mini83.z.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = import_mini83.z.object({
-  name: import_mini83.z.string(),
-  body: import_mini83.z.string()
+var rulesyncOperationSchema = import_mini84.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini84.z.object({
+  name: import_mini84.z.string(),
+  body: import_mini84.z.string()
 });
-var rulesyncToolSchema = import_mini83.z.object({
+var rulesyncToolSchema = import_mini84.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini83.z.optional(import_mini83.z.string()),
-  frontmatter: import_mini83.z.optional(import_mini83.z.unknown()),
-  body: import_mini83.z.optional(import_mini83.z.string()),
-  otherFiles: import_mini83.z.optional(import_mini83.z.array(skillFileSchema)),
-  content: import_mini83.z.optional(import_mini83.z.string()),
-  generateOptions: import_mini83.z.optional(generateOptionsSchema),
-  importOptions: import_mini83.z.optional(importOptionsSchema)
+  targetPathFromCwd: import_mini84.z.optional(import_mini84.z.string()),
+  frontmatter: import_mini84.z.optional(import_mini84.z.unknown()),
+  body: import_mini84.z.optional(import_mini84.z.string()),
+  otherFiles: import_mini84.z.optional(import_mini84.z.array(skillFileSchema)),
+  content: import_mini84.z.optional(import_mini84.z.string()),
+  generateOptions: import_mini84.z.optional(generateOptionsSchema),
+  importOptions: import_mini84.z.optional(importOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -25191,7 +25606,7 @@ async function mcpCommand(logger5, { version }) {
 }
 
 // src/cli/commands/resolve-gitignore-targets.ts
-var import_node_path152 = require("path");
+var import_node_path153 = require("path");
 var resolveGitignoreTargets = async ({
   cliTargets,
   cwd = process.cwd()
@@ -25199,8 +25614,8 @@ var resolveGitignoreTargets = async ({
   if (cliTargets !== void 0) {
     return cliTargets;
   }
-  const baseConfigPath = (0, import_node_path152.join)(cwd, RULESYNC_CONFIG_RELATIVE_FILE_PATH);
-  const localConfigPath = (0, import_node_path152.join)(cwd, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
+  const baseConfigPath = (0, import_node_path153.join)(cwd, RULESYNC_CONFIG_RELATIVE_FILE_PATH);
+  const localConfigPath = (0, import_node_path153.join)(cwd, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH);
   const [hasBase, hasLocal] = await Promise.all([
     fileExists(baseConfigPath),
     fileExists(localConfigPath)
@@ -25210,7 +25625,11 @@ var resolveGitignoreTargets = async ({
   }
   const config = await ConfigResolver.resolve({});
   if (config.getGitignoreTargetsOnly()) {
-    return config.getTargets();
+    const targets = config.getTargets();
+    if (targets.includes("agentsmd")) {
+      return targets;
+    }
+    return [...targets, "agentsmd"];
   }
   return void 0;
 };
@@ -25617,7 +26036,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.1.0";
+var getVersion = () => "8.3.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }