rulesync 7.28.0 → 7.30.0

package/dist/cli/index.cjs

@@ -41,10 +41,21 @@ var ALL_FEATURES = [
 var ALL_FEATURES_WITH_WILDCARD = [...ALL_FEATURES, "*"];
 var FeatureSchema = import_mini.z.enum(ALL_FEATURES);
 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 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.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])
+  )
 ]);
+var isFeatureValueEnabled = (value) => {
+  if (value === true) return true;
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) return true;
+  return false;
+};
 
 // src/utils/error.ts
 var import_zod = require("zod");
@@ -5064,7 +5075,7 @@ var HooksProcessor = class extends FeatureProcessor {
 };
 
 // src/features/ignore/ignore-processor.ts
-var import_mini20 = require("zod/mini");
+var import_mini21 = require("zod/mini");
 
 // src/features/ignore/augmentcode-ignore.ts
 var import_node_path33 = require("path");
@@ -5140,7 +5151,7 @@ var ToolIgnore = class extends ToolFile {
       }
     }
   }
-  static getSettablePaths() {
+  static getSettablePaths(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
   getPatterns() {
@@ -5243,21 +5254,47 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
 // src/features/ignore/claudecode-ignore.ts
 var import_node_path34 = require("path");
 var import_es_toolkit2 = require("es-toolkit");
+var import_mini20 = require("zod/mini");
+var SHARED_SETTINGS_FILE = "settings.json";
+var LOCAL_SETTINGS_FILE = "settings.local.json";
+var DEFAULT_FILE_MODE = "shared";
+var ClaudecodeIgnoreOptionsSchema = import_mini20.z.looseObject({
+  fileMode: import_mini20.z.optional(import_mini20.z.enum(["shared", "local"]))
+});
+var resolveFileMode = (options) => {
+  if (!options) return DEFAULT_FILE_MODE;
+  const parsed = ClaudecodeIgnoreOptionsSchema.safeParse(options);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid options for claudecode ignore feature: ${parsed.error.message}. \`fileMode\` must be either "shared" or "local".`
+    );
+  }
+  return parsed.data.fileMode ?? DEFAULT_FILE_MODE;
+};
+var fileNameForMode = (fileMode) => {
+  return fileMode === "local" ? LOCAL_SETTINGS_FILE : SHARED_SETTINGS_FILE;
+};
 var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
   constructor(params) {
     super(params);
     const jsonValue = JSON.parse(this.fileContent);
     this.patterns = jsonValue.permissions?.deny ?? [];
   }
-  static getSettablePaths() {
+  static getSettablePaths(params) {
+    const fileMode = resolveFileMode(params?.options);
     return {
       relativeDirPath: ".claude",
-      relativeFilePath: "settings.json"
+      relativeFilePath: fileNameForMode(fileMode)
     };
   }
   /**
-   * ClaudecodeIgnore uses settings.json, which can include non-ignore settings.
-   * It should not be deleted by rulesync.
+   * ClaudecodeIgnore uses settings.json (or settings.local.json), which can
+   * include non-ignore settings. It should not be deleted by rulesync.
+   *
+   * NOTE: Because this returns `false`, switching `fileMode` (e.g. from
+   * `"local"` to `"shared"`) will not automatically clean up deny patterns
+   * in the previously-used file. Users must manually remove stale deny
+   * entries from the old file when changing `fileMode`.
    */
   isDeletable() {
     return false;
@@ -5279,16 +5316,14 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
   }
   static async fromRulesyncIgnore({
     baseDir = process.cwd(),
-    rulesyncIgnore
+    rulesyncIgnore,
+    options
   }) {
     const fileContent = rulesyncIgnore.getFileContent();
     const patterns = fileContent.split(/\r?\n|\r/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
     const deniedValues = patterns.map((pattern) => `Read(${pattern})`);
-    const filePath = (0, import_node_path34.join)(
-      baseDir,
-      this.getSettablePaths().relativeDirPath,
-      this.getSettablePaths().relativeFilePath
-    );
+    const paths = this.getSettablePaths({ options });
+    const filePath = (0, import_node_path34.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
     const exists = await fileExists(filePath);
     const existingFileContent = exists ? await readFileContent(filePath) : "{}";
     const existingJsonValue = JSON.parse(existingFileContent);
@@ -5309,27 +5344,29 @@ var ClaudecodeIgnore = class _ClaudecodeIgnore extends ToolIgnore {
     };
     return new _ClaudecodeIgnore({
       baseDir,
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: this.getSettablePaths().relativeFilePath,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
       fileContent: JSON.stringify(jsonValue, null, 2),
       validate: true
     });
   }
   static async fromFile({
     baseDir = process.cwd(),
-    validate = true
+    validate = true,
+    options
   }) {
-    const fileContent = await readFileContent(
-      (0, import_node_path34.join)(
-        baseDir,
-        this.getSettablePaths().relativeDirPath,
-        this.getSettablePaths().relativeFilePath
-      )
-    );
+    const fileMode = resolveFileMode(options);
+    const paths = this.getSettablePaths({ options });
+    const filePath = (0, import_node_path34.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const exists = await fileExists(filePath);
+    if (!exists && fileMode === "shared") {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const fileContent = exists ? await readFileContent(filePath) : "{}";
     return new _ClaudecodeIgnore({
       baseDir,
-      relativeDirPath: this.getSettablePaths().relativeDirPath,
-      relativeFilePath: this.getSettablePaths().relativeFilePath,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
       fileContent,
       validate
     });
@@ -6066,7 +6103,7 @@ var ignoreProcessorToolTargets = [
   "windsurf",
   "zed"
 ];
-var IgnoreProcessorToolTargetSchema = import_mini20.z.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = import_mini21.z.enum(ignoreProcessorToolTargets);
 var toolIgnoreFactories = /* @__PURE__ */ new Map([
   ["augmentcode", { class: AugmentcodeIgnore }],
   ["claudecode", { class: ClaudecodeIgnore }],
@@ -6093,12 +6130,14 @@ var defaultGetFactory2 = (target) => {
 var IgnoreProcessor = class extends FeatureProcessor {
   toolTarget;
   getFactory;
+  featureOptions;
   constructor({
     baseDir = process.cwd(),
     toolTarget,
     getFactory = defaultGetFactory2,
     dryRun = false,
-    logger: logger5
+    logger: logger5,
+    featureOptions
   }) {
     super({ baseDir, dryRun, logger: logger5 });
     const result = IgnoreProcessorToolTargetSchema.safeParse(toolTarget);
@@ -6109,6 +6148,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
     }
     this.toolTarget = result.data;
     this.getFactory = getFactory;
+    this.featureOptions = featureOptions;
   }
   async writeToolIgnoresFromRulesyncIgnores(rulesyncIgnores) {
     const toolIgnores = await this.convertRulesyncFilesToToolFiles(rulesyncIgnores);
@@ -6137,7 +6177,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
   } = {}) {
     try {
       const factory = this.getFactory(this.toolTarget);
-      const paths = factory.class.getSettablePaths();
+      const paths = factory.class.getSettablePaths({ options: this.featureOptions });
       if (forDeletion) {
         const toolIgnore = factory.class.forDeletion({
           baseDir: this.baseDir,
@@ -6161,7 +6201,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
   }
   async loadToolIgnores() {
     const factory = this.getFactory(this.toolTarget);
-    return [await factory.class.fromFile({ baseDir: this.baseDir })];
+    return [await factory.class.fromFile({ baseDir: this.baseDir, options: this.featureOptions })];
   }
   /**
    * Implementation of abstract method from FeatureProcessor
@@ -6177,7 +6217,8 @@ var IgnoreProcessor = class extends FeatureProcessor {
     const factory = this.getFactory(this.toolTarget);
     const toolIgnore = await factory.class.fromRulesyncIgnore({
       baseDir: this.baseDir,
-      rulesyncIgnore
+      rulesyncIgnore,
+      options: this.featureOptions
     });
     return [toolIgnore];
   }
@@ -6205,7 +6246,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/features/mcp/mcp-processor.ts
-var import_mini25 = require("zod/mini");
+var import_mini26 = require("zod/mini");
 
 // src/features/mcp/claudecode-mcp.ts
 var import_node_path47 = require("path");
@@ -6213,47 +6254,47 @@ var import_node_path47 = require("path");
 // src/features/mcp/rulesync-mcp.ts
 var import_node_path46 = require("path");
 var import_object = require("es-toolkit/object");
-var import_mini22 = require("zod/mini");
+var import_mini23 = require("zod/mini");
 
 // src/types/mcp.ts
-var import_mini21 = require("zod/mini");
-var McpServerSchema = import_mini21.z.looseObject({
-  type: import_mini21.z.optional(import_mini21.z.enum(["local", "stdio", "sse", "http"])),
-  command: import_mini21.z.optional(import_mini21.z.union([import_mini21.z.string(), import_mini21.z.array(import_mini21.z.string())])),
-  args: import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string())),
-  url: import_mini21.z.optional(import_mini21.z.string()),
-  httpUrl: import_mini21.z.optional(import_mini21.z.string()),
-  env: import_mini21.z.optional(import_mini21.z.record(import_mini21.z.string(), import_mini21.z.string())),
-  disabled: import_mini21.z.optional(import_mini21.z.boolean()),
-  networkTimeout: import_mini21.z.optional(import_mini21.z.number()),
-  timeout: import_mini21.z.optional(import_mini21.z.number()),
-  trust: import_mini21.z.optional(import_mini21.z.boolean()),
-  cwd: import_mini21.z.optional(import_mini21.z.string()),
-  transport: import_mini21.z.optional(import_mini21.z.enum(["local", "stdio", "sse", "http"])),
-  alwaysAllow: import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string())),
-  tools: import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string())),
-  kiroAutoApprove: import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string())),
-  kiroAutoBlock: import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string())),
-  headers: import_mini21.z.optional(import_mini21.z.record(import_mini21.z.string(), import_mini21.z.string())),
-  enabledTools: import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string())),
-  disabledTools: import_mini21.z.optional(import_mini21.z.array(import_mini21.z.string()))
+var import_mini22 = require("zod/mini");
+var McpServerSchema = import_mini22.z.looseObject({
+  type: import_mini22.z.optional(import_mini22.z.enum(["local", "stdio", "sse", "http"])),
+  command: import_mini22.z.optional(import_mini22.z.union([import_mini22.z.string(), import_mini22.z.array(import_mini22.z.string())])),
+  args: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  url: import_mini22.z.optional(import_mini22.z.string()),
+  httpUrl: import_mini22.z.optional(import_mini22.z.string()),
+  env: import_mini22.z.optional(import_mini22.z.record(import_mini22.z.string(), import_mini22.z.string())),
+  disabled: import_mini22.z.optional(import_mini22.z.boolean()),
+  networkTimeout: import_mini22.z.optional(import_mini22.z.number()),
+  timeout: import_mini22.z.optional(import_mini22.z.number()),
+  trust: import_mini22.z.optional(import_mini22.z.boolean()),
+  cwd: import_mini22.z.optional(import_mini22.z.string()),
+  transport: import_mini22.z.optional(import_mini22.z.enum(["local", "stdio", "sse", "http"])),
+  alwaysAllow: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  tools: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  kiroAutoApprove: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  kiroAutoBlock: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  headers: import_mini22.z.optional(import_mini22.z.record(import_mini22.z.string(), import_mini22.z.string())),
+  enabledTools: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  disabledTools: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string()))
 });
-var McpServersSchema = import_mini21.z.record(import_mini21.z.string(), McpServerSchema);
+var McpServersSchema = import_mini22.z.record(import_mini22.z.string(), McpServerSchema);
 function isMcpServers(value) {
   return value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
 // src/features/mcp/rulesync-mcp.ts
-var RulesyncMcpServerSchema = import_mini22.z.extend(McpServerSchema, {
-  targets: import_mini22.z.optional(RulesyncTargetsSchema),
-  description: import_mini22.z.optional(import_mini22.z.string()),
-  exposed: import_mini22.z.optional(import_mini22.z.boolean())
+var RulesyncMcpServerSchema = import_mini23.z.extend(McpServerSchema, {
+  targets: import_mini23.z.optional(RulesyncTargetsSchema),
+  description: import_mini23.z.optional(import_mini23.z.string()),
+  exposed: import_mini23.z.optional(import_mini23.z.boolean())
 });
-var RulesyncMcpConfigSchema = import_mini22.z.object({
-  mcpServers: import_mini22.z.record(import_mini22.z.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = import_mini23.z.object({
+  mcpServers: import_mini23.z.record(import_mini23.z.string(), RulesyncMcpServerSchema)
 });
-var RulesyncMcpFileSchema = import_mini22.z.looseObject({
-  $schema: import_mini22.z.optional(import_mini22.z.string()),
+var RulesyncMcpFileSchema = import_mini23.z.looseObject({
+  $schema: import_mini23.z.optional(import_mini23.z.string()),
   ...RulesyncMcpConfigSchema.shape
 });
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
@@ -7454,25 +7495,25 @@ var JunieMcp = class _JunieMcp extends ToolMcp {
 // src/features/mcp/kilo-mcp.ts
 var import_node_path57 = require("path");
 var import_jsonc_parser2 = require("jsonc-parser");
-var import_mini23 = require("zod/mini");
-var KiloMcpLocalServerSchema = import_mini23.z.object({
-  type: import_mini23.z.literal("local"),
-  command: import_mini23.z.array(import_mini23.z.string()),
-  environment: import_mini23.z.optional(import_mini23.z.record(import_mini23.z.string(), import_mini23.z.string())),
-  enabled: import_mini23.z._default(import_mini23.z.boolean(), true),
-  cwd: import_mini23.z.optional(import_mini23.z.string())
+var import_mini24 = require("zod/mini");
+var KiloMcpLocalServerSchema = import_mini24.z.object({
+  type: import_mini24.z.literal("local"),
+  command: import_mini24.z.array(import_mini24.z.string()),
+  environment: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.string())),
+  enabled: import_mini24.z._default(import_mini24.z.boolean(), true),
+  cwd: import_mini24.z.optional(import_mini24.z.string())
 });
-var KiloMcpRemoteServerSchema = import_mini23.z.object({
-  type: import_mini23.z.literal("remote"),
-  url: import_mini23.z.string(),
-  headers: import_mini23.z.optional(import_mini23.z.record(import_mini23.z.string(), import_mini23.z.string())),
-  enabled: import_mini23.z._default(import_mini23.z.boolean(), true)
+var KiloMcpRemoteServerSchema = import_mini24.z.object({
+  type: import_mini24.z.literal("remote"),
+  url: import_mini24.z.string(),
+  headers: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.string())),
+  enabled: import_mini24.z._default(import_mini24.z.boolean(), true)
 });
-var KiloMcpServerSchema = import_mini23.z.union([KiloMcpLocalServerSchema, KiloMcpRemoteServerSchema]);
-var KiloConfigSchema = import_mini23.z.looseObject({
-  $schema: import_mini23.z.optional(import_mini23.z.string()),
-  mcp: import_mini23.z.optional(import_mini23.z.record(import_mini23.z.string(), KiloMcpServerSchema)),
-  tools: import_mini23.z.optional(import_mini23.z.record(import_mini23.z.string(), import_mini23.z.boolean()))
+var KiloMcpServerSchema = import_mini24.z.union([KiloMcpLocalServerSchema, KiloMcpRemoteServerSchema]);
+var KiloConfigSchema = import_mini24.z.looseObject({
+  $schema: import_mini24.z.optional(import_mini24.z.string()),
+  mcp: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), KiloMcpServerSchema)),
+  tools: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.boolean()))
 });
 function convertFromKiloFormat(kiloMcp, tools) {
   return Object.fromEntries(
@@ -7769,28 +7810,28 @@ var KiroMcp = class _KiroMcp extends ToolMcp {
 // src/features/mcp/opencode-mcp.ts
 var import_node_path59 = require("path");
 var import_jsonc_parser3 = require("jsonc-parser");
-var import_mini24 = require("zod/mini");
-var OpencodeMcpLocalServerSchema = import_mini24.z.object({
-  type: import_mini24.z.literal("local"),
-  command: import_mini24.z.array(import_mini24.z.string()),
-  environment: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.string())),
-  enabled: import_mini24.z._default(import_mini24.z.boolean(), true),
-  cwd: import_mini24.z.optional(import_mini24.z.string())
+var import_mini25 = require("zod/mini");
+var OpencodeMcpLocalServerSchema = import_mini25.z.object({
+  type: import_mini25.z.literal("local"),
+  command: import_mini25.z.array(import_mini25.z.string()),
+  environment: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.string())),
+  enabled: import_mini25.z._default(import_mini25.z.boolean(), true),
+  cwd: import_mini25.z.optional(import_mini25.z.string())
 });
-var OpencodeMcpRemoteServerSchema = import_mini24.z.object({
-  type: import_mini24.z.literal("remote"),
-  url: import_mini24.z.string(),
-  headers: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.string())),
-  enabled: import_mini24.z._default(import_mini24.z.boolean(), true)
+var OpencodeMcpRemoteServerSchema = import_mini25.z.object({
+  type: import_mini25.z.literal("remote"),
+  url: import_mini25.z.string(),
+  headers: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.string())),
+  enabled: import_mini25.z._default(import_mini25.z.boolean(), true)
 });
-var OpencodeMcpServerSchema = import_mini24.z.union([
+var OpencodeMcpServerSchema = import_mini25.z.union([
   OpencodeMcpLocalServerSchema,
   OpencodeMcpRemoteServerSchema
 ]);
-var OpencodeConfigSchema = import_mini24.z.looseObject({
-  $schema: import_mini24.z.optional(import_mini24.z.string()),
-  mcp: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), OpencodeMcpServerSchema)),
-  tools: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.boolean()))
+var OpencodeConfigSchema = import_mini25.z.looseObject({
+  $schema: import_mini25.z.optional(import_mini25.z.string()),
+  mcp: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), OpencodeMcpServerSchema)),
+  tools: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.boolean()))
 });
 function convertFromOpencodeFormat(opencodeMcp, tools) {
   return Object.fromEntries(
@@ -8261,7 +8302,7 @@ var mcpProcessorToolTargetTuple = [
   "roo",
   "rovodev"
 ];
-var McpProcessorToolTargetSchema = import_mini25.z.enum(mcpProcessorToolTargetTuple);
+var McpProcessorToolTargetSchema = import_mini26.z.enum(mcpProcessorToolTargetTuple);
 var toolMcpFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -8602,7 +8643,7 @@ var McpProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path131 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini64 = require("zod/mini");
+var import_mini65 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -8612,7 +8653,7 @@ var import_node_path65 = require("path");
 
 // src/features/skills/simulated-skill.ts
 var import_node_path64 = require("path");
-var import_mini26 = require("zod/mini");
+var import_mini27 = require("zod/mini");
 
 // src/features/skills/tool-skill.ts
 var import_node_path63 = require("path");
@@ -8849,9 +8890,9 @@ var ToolSkill = class extends AiDir {
 };
 
 // src/features/skills/simulated-skill.ts
-var SimulatedSkillFrontmatterSchema = import_mini26.z.looseObject({
-  name: import_mini26.z.string(),
-  description: import_mini26.z.string()
+var SimulatedSkillFrontmatterSchema = import_mini27.z.looseObject({
+  name: import_mini27.z.string(),
+  description: import_mini27.z.string()
 });
 var SimulatedSkill = class extends ToolSkill {
   frontmatter;
@@ -9078,49 +9119,49 @@ var FactorydroidSkill = class _FactorydroidSkill extends SimulatedSkill {
 
 // src/features/skills/rovodev-skill.ts
 var import_node_path68 = require("path");
-var import_mini28 = require("zod/mini");
+var import_mini29 = require("zod/mini");
 
 // src/features/skills/rulesync-skill.ts
 var import_node_path67 = require("path");
-var import_mini27 = require("zod/mini");
-var RulesyncSkillFrontmatterSchemaInternal = import_mini27.z.looseObject({
-  name: import_mini27.z.string(),
-  description: import_mini27.z.string(),
-  targets: import_mini27.z._default(RulesyncTargetsSchema, ["*"]),
-  claudecode: import_mini27.z.optional(
-    import_mini27.z.looseObject({
-      "allowed-tools": import_mini27.z.optional(import_mini27.z.array(import_mini27.z.string())),
-      model: import_mini27.z.optional(import_mini27.z.string()),
-      "disable-model-invocation": import_mini27.z.optional(import_mini27.z.boolean())
+var import_mini28 = require("zod/mini");
+var RulesyncSkillFrontmatterSchemaInternal = import_mini28.z.looseObject({
+  name: import_mini28.z.string(),
+  description: import_mini28.z.string(),
+  targets: import_mini28.z._default(RulesyncTargetsSchema, ["*"]),
+  claudecode: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      "allowed-tools": import_mini28.z.optional(import_mini28.z.array(import_mini28.z.string())),
+      model: import_mini28.z.optional(import_mini28.z.string()),
+      "disable-model-invocation": import_mini28.z.optional(import_mini28.z.boolean())
     })
   ),
-  codexcli: import_mini27.z.optional(
-    import_mini27.z.looseObject({
-      "short-description": import_mini27.z.optional(import_mini27.z.string())
+  codexcli: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      "short-description": import_mini28.z.optional(import_mini28.z.string())
     })
   ),
-  opencode: import_mini27.z.optional(
-    import_mini27.z.looseObject({
-      "allowed-tools": import_mini27.z.optional(import_mini27.z.array(import_mini27.z.string()))
+  opencode: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      "allowed-tools": import_mini28.z.optional(import_mini28.z.array(import_mini28.z.string()))
     })
   ),
-  kilo: import_mini27.z.optional(
-    import_mini27.z.looseObject({
-      "allowed-tools": import_mini27.z.optional(import_mini27.z.array(import_mini27.z.string()))
+  kilo: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      "allowed-tools": import_mini28.z.optional(import_mini28.z.array(import_mini28.z.string()))
     })
   ),
-  deepagents: import_mini27.z.optional(
-    import_mini27.z.looseObject({
-      "allowed-tools": import_mini27.z.optional(import_mini27.z.array(import_mini27.z.string()))
+  deepagents: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      "allowed-tools": import_mini28.z.optional(import_mini28.z.array(import_mini28.z.string()))
     })
   ),
-  copilot: import_mini27.z.optional(
-    import_mini27.z.looseObject({
-      license: import_mini27.z.optional(import_mini27.z.string())
+  copilot: import_mini28.z.optional(
+    import_mini28.z.looseObject({
+      license: import_mini28.z.optional(import_mini28.z.string())
     })
   ),
-  cline: import_mini27.z.optional(import_mini27.z.looseObject({})),
-  roo: import_mini27.z.optional(import_mini27.z.looseObject({}))
+  cline: import_mini28.z.optional(import_mini28.z.looseObject({})),
+  roo: import_mini28.z.optional(import_mini28.z.looseObject({}))
 });
 var RulesyncSkillFrontmatterSchema = RulesyncSkillFrontmatterSchemaInternal;
 var RulesyncSkill = class _RulesyncSkill extends AiDir {
@@ -9217,9 +9258,9 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
 };
 
 // src/features/skills/rovodev-skill.ts
-var RovodevSkillFrontmatterSchema = import_mini28.z.looseObject({
-  name: import_mini28.z.string(),
-  description: import_mini28.z.string()
+var RovodevSkillFrontmatterSchema = import_mini29.z.looseObject({
+  name: import_mini29.z.string(),
+  description: import_mini29.z.string()
 });
 var RovodevSkill = class _RovodevSkill extends ToolSkill {
   constructor({
@@ -9391,7 +9432,7 @@ var RovodevSkill = class _RovodevSkill extends ToolSkill {
 
 // src/features/skills/skills-processor.ts
 var import_node_path86 = require("path");
-var import_mini44 = require("zod/mini");
+var import_mini45 = require("zod/mini");
 
 // src/types/dir-feature-processor.ts
 var import_node_path69 = require("path");
@@ -9530,10 +9571,10 @@ var DirFeatureProcessor = class {
 
 // src/features/skills/agentsskills-skill.ts
 var import_node_path70 = require("path");
-var import_mini29 = require("zod/mini");
-var AgentsSkillsSkillFrontmatterSchema = import_mini29.z.looseObject({
-  name: import_mini29.z.string(),
-  description: import_mini29.z.string()
+var import_mini30 = require("zod/mini");
+var AgentsSkillsSkillFrontmatterSchema = import_mini30.z.looseObject({
+  name: import_mini30.z.string(),
+  description: import_mini30.z.string()
 });
 var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
   constructor({
@@ -9688,10 +9729,10 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
 
 // src/features/skills/antigravity-skill.ts
 var import_node_path71 = require("path");
-var import_mini30 = require("zod/mini");
-var AntigravitySkillFrontmatterSchema = import_mini30.z.looseObject({
-  name: import_mini30.z.string(),
-  description: import_mini30.z.string()
+var import_mini31 = require("zod/mini");
+var AntigravitySkillFrontmatterSchema = import_mini31.z.looseObject({
+  name: import_mini31.z.string(),
+  description: import_mini31.z.string()
 });
 var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
   constructor({
@@ -9849,13 +9890,13 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
 
 // src/features/skills/claudecode-skill.ts
 var import_node_path72 = require("path");
-var import_mini31 = require("zod/mini");
-var ClaudecodeSkillFrontmatterSchema = import_mini31.z.looseObject({
-  name: import_mini31.z.string(),
-  description: import_mini31.z.string(),
-  "allowed-tools": import_mini31.z.optional(import_mini31.z.array(import_mini31.z.string())),
-  model: import_mini31.z.optional(import_mini31.z.string()),
-  "disable-model-invocation": import_mini31.z.optional(import_mini31.z.boolean())
+var import_mini32 = require("zod/mini");
+var ClaudecodeSkillFrontmatterSchema = import_mini32.z.looseObject({
+  name: import_mini32.z.string(),
+  description: import_mini32.z.string(),
+  "allowed-tools": import_mini32.z.optional(import_mini32.z.array(import_mini32.z.string())),
+  model: import_mini32.z.optional(import_mini32.z.string()),
+  "disable-model-invocation": import_mini32.z.optional(import_mini32.z.boolean())
 });
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
@@ -10025,10 +10066,10 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
 
 // src/features/skills/cline-skill.ts
 var import_node_path73 = require("path");
-var import_mini32 = require("zod/mini");
-var ClineSkillFrontmatterSchema = import_mini32.z.looseObject({
-  name: import_mini32.z.string(),
-  description: import_mini32.z.string()
+var import_mini33 = require("zod/mini");
+var ClineSkillFrontmatterSchema = import_mini33.z.looseObject({
+  name: import_mini33.z.string(),
+  description: import_mini33.z.string()
 });
 var ClineSkill = class _ClineSkill extends ToolSkill {
   constructor({
@@ -10198,13 +10239,13 @@ var ClineSkill = class _ClineSkill extends ToolSkill {
 
 // src/features/skills/codexcli-skill.ts
 var import_node_path74 = require("path");
-var import_mini33 = require("zod/mini");
-var CodexCliSkillFrontmatterSchema = import_mini33.z.looseObject({
-  name: import_mini33.z.string(),
-  description: import_mini33.z.string(),
-  metadata: import_mini33.z.optional(
-    import_mini33.z.looseObject({
-      "short-description": import_mini33.z.optional(import_mini33.z.string())
+var import_mini34 = require("zod/mini");
+var CodexCliSkillFrontmatterSchema = import_mini34.z.looseObject({
+  name: import_mini34.z.string(),
+  description: import_mini34.z.string(),
+  metadata: import_mini34.z.optional(
+    import_mini34.z.looseObject({
+      "short-description": import_mini34.z.optional(import_mini34.z.string())
     })
   )
 });
@@ -10369,11 +10410,11 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
 
 // src/features/skills/copilot-skill.ts
 var import_node_path75 = require("path");
-var import_mini34 = require("zod/mini");
-var CopilotSkillFrontmatterSchema = import_mini34.z.looseObject({
-  name: import_mini34.z.string(),
-  description: import_mini34.z.string(),
-  license: import_mini34.z.optional(import_mini34.z.string())
+var import_mini35 = require("zod/mini");
+var CopilotSkillFrontmatterSchema = import_mini35.z.looseObject({
+  name: import_mini35.z.string(),
+  description: import_mini35.z.string(),
+  license: import_mini35.z.optional(import_mini35.z.string())
 });
 var CopilotSkill = class _CopilotSkill extends ToolSkill {
   constructor({
@@ -10534,10 +10575,10 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
 
 // src/features/skills/cursor-skill.ts
 var import_node_path76 = require("path");
-var import_mini35 = require("zod/mini");
-var CursorSkillFrontmatterSchema = import_mini35.z.looseObject({
-  name: import_mini35.z.string(),
-  description: import_mini35.z.string()
+var import_mini36 = require("zod/mini");
+var CursorSkillFrontmatterSchema = import_mini36.z.looseObject({
+  name: import_mini36.z.string(),
+  description: import_mini36.z.string()
 });
 var CursorSkill = class _CursorSkill extends ToolSkill {
   constructor({
@@ -10689,11 +10730,11 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
 
 // src/features/skills/deepagents-skill.ts
 var import_node_path77 = require("path");
-var import_mini36 = require("zod/mini");
-var DeepagentsSkillFrontmatterSchema = import_mini36.z.looseObject({
-  name: import_mini36.z.string(),
-  description: import_mini36.z.string(),
-  "allowed-tools": import_mini36.z.optional(import_mini36.z.array(import_mini36.z.string()))
+var import_mini37 = require("zod/mini");
+var DeepagentsSkillFrontmatterSchema = import_mini37.z.looseObject({
+  name: import_mini37.z.string(),
+  description: import_mini37.z.string(),
+  "allowed-tools": import_mini37.z.optional(import_mini37.z.array(import_mini37.z.string()))
 });
 var DeepagentsSkill = class _DeepagentsSkill extends ToolSkill {
   constructor({
@@ -10851,10 +10892,10 @@ var DeepagentsSkill = class _DeepagentsSkill extends ToolSkill {
 
 // src/features/skills/geminicli-skill.ts
 var import_node_path78 = require("path");
-var import_mini37 = require("zod/mini");
-var GeminiCliSkillFrontmatterSchema = import_mini37.z.looseObject({
-  name: import_mini37.z.string(),
-  description: import_mini37.z.string()
+var import_mini38 = require("zod/mini");
+var GeminiCliSkillFrontmatterSchema = import_mini38.z.looseObject({
+  name: import_mini38.z.string(),
+  description: import_mini38.z.string()
 });
 var GeminiCliSkill = class _GeminiCliSkill extends ToolSkill {
   constructor({
@@ -11008,10 +11049,10 @@ var GeminiCliSkill = class _GeminiCliSkill extends ToolSkill {
 
 // src/features/skills/junie-skill.ts
 var import_node_path79 = require("path");
-var import_mini38 = require("zod/mini");
-var JunieSkillFrontmatterSchema = import_mini38.z.looseObject({
-  name: import_mini38.z.string(),
-  description: import_mini38.z.string()
+var import_mini39 = require("zod/mini");
+var JunieSkillFrontmatterSchema = import_mini39.z.looseObject({
+  name: import_mini39.z.string(),
+  description: import_mini39.z.string()
 });
 var JunieSkill = class _JunieSkill extends ToolSkill {
   constructor({
@@ -11184,11 +11225,11 @@ var JunieSkill = class _JunieSkill extends ToolSkill {
 
 // src/features/skills/kilo-skill.ts
 var import_node_path80 = require("path");
-var import_mini39 = require("zod/mini");
-var KiloSkillFrontmatterSchema = import_mini39.z.looseObject({
-  name: import_mini39.z.string(),
-  description: import_mini39.z.string(),
-  "allowed-tools": import_mini39.z.optional(import_mini39.z.array(import_mini39.z.string()))
+var import_mini40 = require("zod/mini");
+var KiloSkillFrontmatterSchema = import_mini40.z.looseObject({
+  name: import_mini40.z.string(),
+  description: import_mini40.z.string(),
+  "allowed-tools": import_mini40.z.optional(import_mini40.z.array(import_mini40.z.string()))
 });
 var KiloSkill = class _KiloSkill extends ToolSkill {
   constructor({
@@ -11345,10 +11386,10 @@ var KiloSkill = class _KiloSkill extends ToolSkill {
 
 // src/features/skills/kiro-skill.ts
 var import_node_path81 = require("path");
-var import_mini40 = require("zod/mini");
-var KiroSkillFrontmatterSchema = import_mini40.z.looseObject({
-  name: import_mini40.z.string(),
-  description: import_mini40.z.string()
+var import_mini41 = require("zod/mini");
+var KiroSkillFrontmatterSchema = import_mini41.z.looseObject({
+  name: import_mini41.z.string(),
+  description: import_mini41.z.string()
 });
 var KiroSkill = class _KiroSkill extends ToolSkill {
   constructor({
@@ -11522,11 +11563,11 @@ var KiroSkill = class _KiroSkill extends ToolSkill {
 
 // src/features/skills/opencode-skill.ts
 var import_node_path82 = require("path");
-var import_mini41 = require("zod/mini");
-var OpenCodeSkillFrontmatterSchema = import_mini41.z.looseObject({
-  name: import_mini41.z.string(),
-  description: import_mini41.z.string(),
-  "allowed-tools": import_mini41.z.optional(import_mini41.z.array(import_mini41.z.string()))
+var import_mini42 = require("zod/mini");
+var OpenCodeSkillFrontmatterSchema = import_mini42.z.looseObject({
+  name: import_mini42.z.string(),
+  description: import_mini42.z.string(),
+  "allowed-tools": import_mini42.z.optional(import_mini42.z.array(import_mini42.z.string()))
 });
 var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
   constructor({
@@ -11683,10 +11724,10 @@ var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
 
 // src/features/skills/replit-skill.ts
 var import_node_path83 = require("path");
-var import_mini42 = require("zod/mini");
-var ReplitSkillFrontmatterSchema = import_mini42.z.looseObject({
-  name: import_mini42.z.string(),
-  description: import_mini42.z.string()
+var import_mini43 = require("zod/mini");
+var ReplitSkillFrontmatterSchema = import_mini43.z.looseObject({
+  name: import_mini43.z.string(),
+  description: import_mini43.z.string()
 });
 var ReplitSkill = class _ReplitSkill extends ToolSkill {
   constructor({
@@ -11841,10 +11882,10 @@ var ReplitSkill = class _ReplitSkill extends ToolSkill {
 
 // src/features/skills/roo-skill.ts
 var import_node_path84 = require("path");
-var import_mini43 = require("zod/mini");
-var RooSkillFrontmatterSchema = import_mini43.z.looseObject({
-  name: import_mini43.z.string(),
-  description: import_mini43.z.string()
+var import_mini44 = require("zod/mini");
+var RooSkillFrontmatterSchema = import_mini44.z.looseObject({
+  name: import_mini44.z.string(),
+  description: import_mini44.z.string()
 });
 var RooSkill = class _RooSkill extends ToolSkill {
   constructor({
@@ -12053,7 +12094,7 @@ var skillsProcessorToolTargetTuple = [
   "roo",
   "rovodev"
 ];
-var SkillsProcessorToolTargetSchema = import_mini44.z.enum(skillsProcessorToolTargetTuple);
+var SkillsProcessorToolTargetSchema = import_mini45.z.enum(skillsProcessorToolTargetTuple);
 var toolSkillFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -12425,7 +12466,7 @@ var import_node_path88 = require("path");
 
 // src/features/subagents/simulated-subagent.ts
 var import_node_path87 = require("path");
-var import_mini45 = require("zod/mini");
+var import_mini46 = require("zod/mini");
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -12477,9 +12518,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = import_mini45.z.object({
-  name: import_mini45.z.string(),
-  description: import_mini45.z.optional(import_mini45.z.string())
+var SimulatedSubagentFrontmatterSchema = import_mini46.z.object({
+  name: import_mini46.z.string(),
+  description: import_mini46.z.optional(import_mini46.z.string())
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -12637,15 +12678,15 @@ var FactorydroidSubagent = class _FactorydroidSubagent extends SimulatedSubagent
 
 // src/features/subagents/geminicli-subagent.ts
 var import_node_path91 = require("path");
-var import_mini47 = require("zod/mini");
+var import_mini48 = require("zod/mini");
 
 // src/features/subagents/rulesync-subagent.ts
 var import_node_path90 = require("path");
-var import_mini46 = require("zod/mini");
-var RulesyncSubagentFrontmatterSchema = import_mini46.z.looseObject({
-  targets: import_mini46.z._default(RulesyncTargetsSchema, ["*"]),
-  name: import_mini46.z.string(),
-  description: import_mini46.z.optional(import_mini46.z.string())
+var import_mini47 = require("zod/mini");
+var RulesyncSubagentFrontmatterSchema = import_mini47.z.looseObject({
+  targets: import_mini47.z._default(RulesyncTargetsSchema, ["*"]),
+  name: import_mini47.z.string(),
+  description: import_mini47.z.optional(import_mini47.z.string())
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -12714,9 +12755,9 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/geminicli-subagent.ts
-var GeminiCliSubagentFrontmatterSchema = import_mini47.z.looseObject({
-  name: import_mini47.z.string(),
-  description: import_mini47.z.optional(import_mini47.z.string())
+var GeminiCliSubagentFrontmatterSchema = import_mini48.z.looseObject({
+  name: import_mini48.z.string(),
+  description: import_mini48.z.optional(import_mini48.z.string())
 });
 var GeminiCliSubagent = class _GeminiCliSubagent extends ToolSubagent {
   frontmatter;
@@ -12889,10 +12930,10 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/rovodev-subagent.ts
 var import_node_path93 = require("path");
-var import_mini48 = require("zod/mini");
-var RovodevSubagentFrontmatterSchema = import_mini48.z.looseObject({
-  name: import_mini48.z.string(),
-  description: import_mini48.z.optional(import_mini48.z.string())
+var import_mini49 = require("zod/mini");
+var RovodevSubagentFrontmatterSchema = import_mini49.z.looseObject({
+  name: import_mini49.z.string(),
+  description: import_mini49.z.optional(import_mini49.z.string())
 });
 var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
   frontmatter;
@@ -13034,18 +13075,18 @@ var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path104 = require("path");
-var import_mini57 = require("zod/mini");
+var import_mini58 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
 var import_node_path94 = require("path");
-var import_mini49 = require("zod/mini");
-var ClaudecodeSubagentFrontmatterSchema = import_mini49.z.looseObject({
-  name: import_mini49.z.string(),
-  description: import_mini49.z.optional(import_mini49.z.string()),
-  model: import_mini49.z.optional(import_mini49.z.string()),
-  tools: import_mini49.z.optional(import_mini49.z.union([import_mini49.z.string(), import_mini49.z.array(import_mini49.z.string())])),
-  permissionMode: import_mini49.z.optional(import_mini49.z.string()),
-  skills: import_mini49.z.optional(import_mini49.z.union([import_mini49.z.string(), import_mini49.z.array(import_mini49.z.string())]))
+var import_mini50 = require("zod/mini");
+var ClaudecodeSubagentFrontmatterSchema = import_mini50.z.looseObject({
+  name: import_mini50.z.string(),
+  description: import_mini50.z.optional(import_mini50.z.string()),
+  model: import_mini50.z.optional(import_mini50.z.string()),
+  tools: import_mini50.z.optional(import_mini50.z.union([import_mini50.z.string(), import_mini50.z.array(import_mini50.z.string())])),
+  permissionMode: import_mini50.z.optional(import_mini50.z.string()),
+  skills: import_mini50.z.optional(import_mini50.z.union([import_mini50.z.string(), import_mini50.z.array(import_mini50.z.string())]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -13201,14 +13242,14 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 // src/features/subagents/codexcli-subagent.ts
 var import_node_path95 = require("path");
 var smolToml4 = __toESM(require("smol-toml"), 1);
-var import_mini50 = require("zod/mini");
-var CodexCliSubagentTomlSchema = import_mini50.z.looseObject({
-  name: import_mini50.z.string(),
-  description: import_mini50.z.optional(import_mini50.z.string()),
-  developer_instructions: import_mini50.z.optional(import_mini50.z.string()),
-  model: import_mini50.z.optional(import_mini50.z.string()),
-  model_reasoning_effort: import_mini50.z.optional(import_mini50.z.string()),
-  sandbox_mode: import_mini50.z.optional(import_mini50.z.string())
+var import_mini51 = require("zod/mini");
+var CodexCliSubagentTomlSchema = import_mini51.z.looseObject({
+  name: import_mini51.z.string(),
+  description: import_mini51.z.optional(import_mini51.z.string()),
+  developer_instructions: import_mini51.z.optional(import_mini51.z.string()),
+  model: import_mini51.z.optional(import_mini51.z.string()),
+  model_reasoning_effort: import_mini51.z.optional(import_mini51.z.string()),
+  sandbox_mode: import_mini51.z.optional(import_mini51.z.string())
 });
 var CodexCliSubagent = class _CodexCliSubagent extends ToolSubagent {
   body;
@@ -13363,12 +13404,12 @@ var CodexCliSubagent = class _CodexCliSubagent extends ToolSubagent {
 
 // src/features/subagents/copilot-subagent.ts
 var import_node_path96 = require("path");
-var import_mini51 = require("zod/mini");
+var import_mini52 = require("zod/mini");
 var REQUIRED_TOOL = "agent/runSubagent";
-var CopilotSubagentFrontmatterSchema = import_mini51.z.looseObject({
-  name: import_mini51.z.string(),
-  description: import_mini51.z.optional(import_mini51.z.string()),
-  tools: import_mini51.z.optional(import_mini51.z.union([import_mini51.z.string(), import_mini51.z.array(import_mini51.z.string())]))
+var CopilotSubagentFrontmatterSchema = import_mini52.z.looseObject({
+  name: import_mini52.z.string(),
+  description: import_mini52.z.optional(import_mini52.z.string()),
+  tools: import_mini52.z.optional(import_mini52.z.union([import_mini52.z.string(), import_mini52.z.array(import_mini52.z.string())]))
 });
 var normalizeTools = (tools) => {
   if (!tools) {
@@ -13529,10 +13570,10 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
 
 // src/features/subagents/cursor-subagent.ts
 var import_node_path97 = require("path");
-var import_mini52 = require("zod/mini");
-var CursorSubagentFrontmatterSchema = import_mini52.z.looseObject({
-  name: import_mini52.z.string(),
-  description: import_mini52.z.optional(import_mini52.z.string())
+var import_mini53 = require("zod/mini");
+var CursorSubagentFrontmatterSchema = import_mini53.z.looseObject({
+  name: import_mini53.z.string(),
+  description: import_mini53.z.optional(import_mini53.z.string())
 });
 var CursorSubagent = class _CursorSubagent extends ToolSubagent {
   frontmatter;
@@ -13676,11 +13717,11 @@ var CursorSubagent = class _CursorSubagent extends ToolSubagent {
 
 // src/features/subagents/deepagents-subagent.ts
 var import_node_path98 = require("path");
-var import_mini53 = require("zod/mini");
-var DeepagentsSubagentFrontmatterSchema = import_mini53.z.looseObject({
-  name: import_mini53.z.string(),
-  description: import_mini53.z.optional(import_mini53.z.string()),
-  model: import_mini53.z.optional(import_mini53.z.string())
+var import_mini54 = require("zod/mini");
+var DeepagentsSubagentFrontmatterSchema = import_mini54.z.looseObject({
+  name: import_mini54.z.string(),
+  description: import_mini54.z.optional(import_mini54.z.string()),
+  model: import_mini54.z.optional(import_mini54.z.string())
 });
 var DeepagentsSubagent = class _DeepagentsSubagent extends ToolSubagent {
   frontmatter;
@@ -13829,10 +13870,10 @@ var DeepagentsSubagent = class _DeepagentsSubagent extends ToolSubagent {
 
 // src/features/subagents/junie-subagent.ts
 var import_node_path99 = require("path");
-var import_mini54 = require("zod/mini");
-var JunieSubagentFrontmatterSchema = import_mini54.z.looseObject({
-  name: import_mini54.z.optional(import_mini54.z.string()),
-  description: import_mini54.z.string()
+var import_mini55 = require("zod/mini");
+var JunieSubagentFrontmatterSchema = import_mini55.z.looseObject({
+  name: import_mini55.z.optional(import_mini55.z.string()),
+  description: import_mini55.z.string()
 });
 var JunieSubagent = class _JunieSubagent extends ToolSubagent {
   frontmatter;
@@ -13990,11 +14031,11 @@ var import_node_path101 = require("path");
 
 // src/features/subagents/opencode-style-subagent.ts
 var import_node_path100 = require("path");
-var import_mini55 = require("zod/mini");
-var OpenCodeStyleSubagentFrontmatterSchema = import_mini55.z.looseObject({
-  description: import_mini55.z.optional(import_mini55.z.string()),
-  mode: import_mini55.z._default(import_mini55.z.string(), "subagent"),
-  name: import_mini55.z.optional(import_mini55.z.string())
+var import_mini56 = require("zod/mini");
+var OpenCodeStyleSubagentFrontmatterSchema = import_mini56.z.looseObject({
+  description: import_mini56.z.optional(import_mini56.z.string()),
+  mode: import_mini56.z._default(import_mini56.z.string(), "subagent"),
+  name: import_mini56.z.optional(import_mini56.z.string())
 });
 var OpenCodeStyleSubagent = class extends ToolSubagent {
   frontmatter;
@@ -14143,22 +14184,22 @@ var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
 
 // src/features/subagents/kiro-subagent.ts
 var import_node_path102 = require("path");
-var import_mini56 = require("zod/mini");
-var KiroCliSubagentJsonSchema = import_mini56.z.looseObject({
-  name: import_mini56.z.string(),
-  description: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.string())),
-  prompt: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.string())),
-  tools: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.array(import_mini56.z.string()))),
-  toolAliases: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.record(import_mini56.z.string(), import_mini56.z.string()))),
-  toolSettings: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.unknown())),
-  toolSchema: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.unknown())),
-  hooks: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.record(import_mini56.z.string(), import_mini56.z.array(import_mini56.z.unknown())))),
-  model: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.string())),
-  mcpServers: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.record(import_mini56.z.string(), import_mini56.z.unknown()))),
-  useLegacyMcpJson: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.boolean())),
-  resources: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.array(import_mini56.z.string()))),
-  allowedTools: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.array(import_mini56.z.string()))),
-  includeMcpJson: import_mini56.z.optional(import_mini56.z.nullable(import_mini56.z.boolean()))
+var import_mini57 = require("zod/mini");
+var KiroCliSubagentJsonSchema = import_mini57.z.looseObject({
+  name: import_mini57.z.string(),
+  description: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.string())),
+  prompt: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.string())),
+  tools: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.array(import_mini57.z.string()))),
+  toolAliases: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.record(import_mini57.z.string(), import_mini57.z.string()))),
+  toolSettings: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.unknown())),
+  toolSchema: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.unknown())),
+  hooks: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.record(import_mini57.z.string(), import_mini57.z.array(import_mini57.z.unknown())))),
+  model: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.string())),
+  mcpServers: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.record(import_mini57.z.string(), import_mini57.z.unknown()))),
+  useLegacyMcpJson: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.boolean())),
+  resources: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.array(import_mini57.z.string()))),
+  allowedTools: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.array(import_mini57.z.string()))),
+  includeMcpJson: import_mini57.z.optional(import_mini57.z.nullable(import_mini57.z.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -14419,7 +14460,7 @@ var subagentsProcessorToolTargetTuple = [
   "roo",
   "rovodev"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini57.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini58.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -14729,42 +14770,42 @@ var import_node_path106 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path105 = require("path");
-var import_mini58 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini58.z.object({
-  root: import_mini58.z.optional(import_mini58.z.boolean()),
-  localRoot: import_mini58.z.optional(import_mini58.z.boolean()),
-  targets: import_mini58.z._default(RulesyncTargetsSchema, ["*"]),
-  description: import_mini58.z.optional(import_mini58.z.string()),
-  globs: import_mini58.z.optional(import_mini58.z.array(import_mini58.z.string())),
-  agentsmd: import_mini58.z.optional(
-    import_mini58.z.looseObject({
+var import_mini59 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini59.z.object({
+  root: import_mini59.z.optional(import_mini59.z.boolean()),
+  localRoot: import_mini59.z.optional(import_mini59.z.boolean()),
+  targets: import_mini59.z._default(RulesyncTargetsSchema, ["*"]),
+  description: import_mini59.z.optional(import_mini59.z.string()),
+  globs: import_mini59.z.optional(import_mini59.z.array(import_mini59.z.string())),
+  agentsmd: import_mini59.z.optional(
+    import_mini59.z.looseObject({
       // @example "path/to/subproject"
-      subprojectPath: import_mini58.z.optional(import_mini58.z.string())
+      subprojectPath: import_mini59.z.optional(import_mini59.z.string())
     })
   ),
-  claudecode: import_mini58.z.optional(
-    import_mini58.z.looseObject({
+  claudecode: import_mini59.z.optional(
+    import_mini59.z.looseObject({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example ["src/**/*.ts", "tests/**/*.test.ts"]
-      paths: import_mini58.z.optional(import_mini58.z.array(import_mini58.z.string()))
+      paths: import_mini59.z.optional(import_mini59.z.array(import_mini59.z.string()))
     })
   ),
-  cursor: import_mini58.z.optional(
-    import_mini58.z.looseObject({
-      alwaysApply: import_mini58.z.optional(import_mini58.z.boolean()),
-      description: import_mini58.z.optional(import_mini58.z.string()),
-      globs: import_mini58.z.optional(import_mini58.z.array(import_mini58.z.string()))
+  cursor: import_mini59.z.optional(
+    import_mini59.z.looseObject({
+      alwaysApply: import_mini59.z.optional(import_mini59.z.boolean()),
+      description: import_mini59.z.optional(import_mini59.z.string()),
+      globs: import_mini59.z.optional(import_mini59.z.array(import_mini59.z.string()))
     })
   ),
-  copilot: import_mini58.z.optional(
-    import_mini58.z.looseObject({
-      excludeAgent: import_mini58.z.optional(import_mini58.z.union([import_mini58.z.literal("code-review"), import_mini58.z.literal("coding-agent")]))
+  copilot: import_mini59.z.optional(
+    import_mini59.z.looseObject({
+      excludeAgent: import_mini59.z.optional(import_mini59.z.union([import_mini59.z.literal("code-review"), import_mini59.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini58.z.optional(
-    import_mini58.z.looseObject({
-      trigger: import_mini58.z.optional(import_mini58.z.string()),
-      globs: import_mini58.z.optional(import_mini58.z.array(import_mini58.z.string()))
+  antigravity: import_mini59.z.optional(
+    import_mini59.z.looseObject({
+      trigger: import_mini59.z.optional(import_mini59.z.string()),
+      globs: import_mini59.z.optional(import_mini59.z.array(import_mini59.z.string()))
     })
   )
 });
@@ -15064,20 +15105,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path108 = require("path");
-var import_mini59 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini59.z.looseObject({
-  trigger: import_mini59.z.optional(
-    import_mini59.z.union([
-      import_mini59.z.literal("always_on"),
-      import_mini59.z.literal("glob"),
-      import_mini59.z.literal("manual"),
-      import_mini59.z.literal("model_decision"),
-      import_mini59.z.string()
+var import_mini60 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini60.z.looseObject({
+  trigger: import_mini60.z.optional(
+    import_mini60.z.union([
+      import_mini60.z.literal("always_on"),
+      import_mini60.z.literal("glob"),
+      import_mini60.z.literal("manual"),
+      import_mini60.z.literal("model_decision"),
+      import_mini60.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini59.z.optional(import_mini59.z.string()),
-  description: import_mini59.z.optional(import_mini59.z.string())
+  globs: import_mini60.z.optional(import_mini60.z.string()),
+  description: import_mini60.z.optional(import_mini60.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -15664,9 +15705,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path112 = require("path");
-var import_mini60 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini60.z.object({
-  paths: import_mini60.z.optional(import_mini60.z.array(import_mini60.z.string()))
+var import_mini61 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini61.z.object({
+  paths: import_mini61.z.optional(import_mini61.z.array(import_mini61.z.string()))
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -15882,9 +15923,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path113 = require("path");
-var import_mini61 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini61.z.object({
-  description: import_mini61.z.string()
+var import_mini62 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini62.z.object({
+  description: import_mini62.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths(_options = {}) {
@@ -16063,11 +16104,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path115 = require("path");
-var import_mini62 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini62.z.object({
-  description: import_mini62.z.optional(import_mini62.z.string()),
-  applyTo: import_mini62.z.optional(import_mini62.z.string()),
-  excludeAgent: import_mini62.z.optional(import_mini62.z.union([import_mini62.z.literal("code-review"), import_mini62.z.literal("coding-agent")]))
+var import_mini63 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini63.z.object({
+  description: import_mini63.z.optional(import_mini63.z.string()),
+  applyTo: import_mini63.z.optional(import_mini63.z.string()),
+  excludeAgent: import_mini63.z.optional(import_mini63.z.union([import_mini63.z.literal("code-review"), import_mini63.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -16309,11 +16350,11 @@ var CopilotcliRule = class _CopilotcliRule extends CopilotRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path116 = require("path");
-var import_mini63 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini63.z.object({
-  description: import_mini63.z.optional(import_mini63.z.string()),
-  globs: import_mini63.z.optional(import_mini63.z.string()),
-  alwaysApply: import_mini63.z.optional(import_mini63.z.boolean())
+var import_mini64 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini64.z.object({
+  description: import_mini64.z.optional(import_mini64.z.string()),
+  globs: import_mini64.z.optional(import_mini64.z.string()),
+  alwaysApply: import_mini64.z.optional(import_mini64.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -17954,7 +17995,7 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini64.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini65.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path131.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
 var toolRuleFactories = /* @__PURE__ */ new Map([
   [
@@ -18877,51 +18918,51 @@ var import_request_error = require("@octokit/request-error");
 var import_rest = require("@octokit/rest");
 
 // src/types/fetch.ts
-var import_mini66 = require("zod/mini");
+var import_mini67 = require("zod/mini");
 
 // src/types/fetch-targets.ts
-var import_mini65 = require("zod/mini");
+var import_mini66 = require("zod/mini");
 var ALL_FETCH_TARGETS = ["rulesync", ...ALL_TOOL_TARGETS];
-var FetchTargetSchema = import_mini65.z.enum(ALL_FETCH_TARGETS);
+var FetchTargetSchema = import_mini66.z.enum(ALL_FETCH_TARGETS);
 
 // src/types/fetch.ts
-var ConflictStrategySchema = import_mini66.z.enum(["skip", "overwrite"]);
-var GitHubFileTypeSchema = import_mini66.z.enum(["file", "dir", "symlink", "submodule"]);
-var GitHubFileEntrySchema = import_mini66.z.looseObject({
-  name: import_mini66.z.string(),
-  path: import_mini66.z.string(),
-  sha: import_mini66.z.string(),
-  size: import_mini66.z.number(),
+var ConflictStrategySchema = import_mini67.z.enum(["skip", "overwrite"]);
+var GitHubFileTypeSchema = import_mini67.z.enum(["file", "dir", "symlink", "submodule"]);
+var GitHubFileEntrySchema = import_mini67.z.looseObject({
+  name: import_mini67.z.string(),
+  path: import_mini67.z.string(),
+  sha: import_mini67.z.string(),
+  size: import_mini67.z.number(),
   type: GitHubFileTypeSchema,
-  download_url: import_mini66.z.nullable(import_mini66.z.string())
+  download_url: import_mini67.z.nullable(import_mini67.z.string())
 });
-var FetchOptionsSchema = import_mini66.z.looseObject({
-  target: import_mini66.z.optional(FetchTargetSchema),
-  features: import_mini66.z.optional(import_mini66.z.array(import_mini66.z.enum(ALL_FEATURES_WITH_WILDCARD))),
-  ref: import_mini66.z.optional(import_mini66.z.string()),
-  path: import_mini66.z.optional(import_mini66.z.string()),
-  output: import_mini66.z.optional(import_mini66.z.string()),
-  conflict: import_mini66.z.optional(ConflictStrategySchema),
-  token: import_mini66.z.optional(import_mini66.z.string()),
-  verbose: import_mini66.z.optional(import_mini66.z.boolean()),
-  silent: import_mini66.z.optional(import_mini66.z.boolean())
+var FetchOptionsSchema = import_mini67.z.looseObject({
+  target: import_mini67.z.optional(FetchTargetSchema),
+  features: import_mini67.z.optional(import_mini67.z.array(import_mini67.z.enum(ALL_FEATURES_WITH_WILDCARD))),
+  ref: import_mini67.z.optional(import_mini67.z.string()),
+  path: import_mini67.z.optional(import_mini67.z.string()),
+  output: import_mini67.z.optional(import_mini67.z.string()),
+  conflict: import_mini67.z.optional(ConflictStrategySchema),
+  token: import_mini67.z.optional(import_mini67.z.string()),
+  verbose: import_mini67.z.optional(import_mini67.z.boolean()),
+  silent: import_mini67.z.optional(import_mini67.z.boolean())
 });
-var FetchFileStatusSchema = import_mini66.z.enum(["created", "overwritten", "skipped"]);
-var GitHubRepoInfoSchema = import_mini66.z.looseObject({
-  default_branch: import_mini66.z.string(),
-  private: import_mini66.z.boolean()
+var FetchFileStatusSchema = import_mini67.z.enum(["created", "overwritten", "skipped"]);
+var GitHubRepoInfoSchema = import_mini67.z.looseObject({
+  default_branch: import_mini67.z.string(),
+  private: import_mini67.z.boolean()
 });
-var GitHubReleaseAssetSchema = import_mini66.z.looseObject({
-  name: import_mini66.z.string(),
-  browser_download_url: import_mini66.z.string(),
-  size: import_mini66.z.number()
+var GitHubReleaseAssetSchema = import_mini67.z.looseObject({
+  name: import_mini67.z.string(),
+  browser_download_url: import_mini67.z.string(),
+  size: import_mini67.z.number()
 });
-var GitHubReleaseSchema = import_mini66.z.looseObject({
-  tag_name: import_mini66.z.string(),
-  name: import_mini66.z.nullable(import_mini66.z.string()),
-  prerelease: import_mini66.z.boolean(),
-  draft: import_mini66.z.boolean(),
-  assets: import_mini66.z.array(GitHubReleaseAssetSchema)
+var GitHubReleaseSchema = import_mini67.z.looseObject({
+  tag_name: import_mini67.z.string(),
+  name: import_mini67.z.nullable(import_mini67.z.string()),
+  prerelease: import_mini67.z.boolean(),
+  draft: import_mini67.z.boolean(),
+  assets: import_mini67.z.array(GitHubReleaseAssetSchema)
 });
 
 // src/lib/github-client.ts
@@ -19222,9 +19263,9 @@ async function listDirectoryRecursive(params) {
 }
 
 // src/types/git-provider.ts
-var import_mini67 = require("zod/mini");
+var import_mini68 = require("zod/mini");
 var ALL_GIT_PROVIDERS = ["github", "gitlab"];
-var GitProviderSchema = import_mini67.z.enum(ALL_GIT_PROVIDERS);
+var GitProviderSchema = import_mini68.z.enum(ALL_GIT_PROVIDERS);
 
 // src/lib/source-parser.ts
 var GITHUB_HOSTS = /* @__PURE__ */ new Set(["github.com", "www.github.com"]);
@@ -19847,7 +19888,7 @@ var import_jsonc_parser4 = require("jsonc-parser");
 
 // src/config/config.ts
 var import_node_path133 = require("path");
-var import_mini68 = require("zod/mini");
+var import_mini69 = require("zod/mini");
 
 // src/utils/validation.ts
 function findControlCharacter(value) {
@@ -19864,53 +19905,53 @@ function hasControlCharacters(value) {
 }
 
 // src/config/config.ts
-var SourceEntrySchema = import_mini68.z.object({
-  source: import_mini68.z.string().check((0, import_mini68.minLength)(1, "source must be a non-empty string")),
-  skills: (0, import_mini68.optional)(import_mini68.z.array(import_mini68.z.string())),
-  transport: (0, import_mini68.optional)(import_mini68.z.enum(["github", "git"])),
-  ref: (0, import_mini68.optional)(
-    import_mini68.z.string().check(
-      (0, import_mini68.refine)((v) => !v.startsWith("-"), 'ref must not start with "-"'),
-      (0, import_mini68.refine)((v) => !hasControlCharacters(v), "ref must not contain control characters")
+var SourceEntrySchema = import_mini69.z.object({
+  source: import_mini69.z.string().check((0, import_mini69.minLength)(1, "source must be a non-empty string")),
+  skills: (0, import_mini69.optional)(import_mini69.z.array(import_mini69.z.string())),
+  transport: (0, import_mini69.optional)(import_mini69.z.enum(["github", "git"])),
+  ref: (0, import_mini69.optional)(
+    import_mini69.z.string().check(
+      (0, import_mini69.refine)((v) => !v.startsWith("-"), 'ref must not start with "-"'),
+      (0, import_mini69.refine)((v) => !hasControlCharacters(v), "ref must not contain control characters")
     )
   ),
-  path: (0, import_mini68.optional)(
-    import_mini68.z.string().check(
-      (0, import_mini68.refine)((v) => !v.includes(".."), 'path must not contain ".."'),
-      (0, import_mini68.refine)((v) => !(0, import_node_path133.isAbsolute)(v), "path must not be absolute"),
-      (0, import_mini68.refine)((v) => !hasControlCharacters(v), "path must not contain control characters")
+  path: (0, import_mini69.optional)(
+    import_mini69.z.string().check(
+      (0, import_mini69.refine)((v) => !v.includes(".."), 'path must not contain ".."'),
+      (0, import_mini69.refine)((v) => !(0, import_node_path133.isAbsolute)(v), "path must not be absolute"),
+      (0, import_mini69.refine)((v) => !hasControlCharacters(v), "path must not contain control characters")
     )
   )
 });
-var ConfigParamsSchema = import_mini68.z.object({
-  baseDirs: import_mini68.z.array(import_mini68.z.string()),
+var ConfigParamsSchema = import_mini69.z.object({
+  baseDirs: import_mini69.z.array(import_mini69.z.string()),
   targets: RulesyncTargetsSchema,
   features: RulesyncFeaturesSchema,
-  verbose: import_mini68.z.boolean(),
-  delete: import_mini68.z.boolean(),
+  verbose: import_mini69.z.boolean(),
+  delete: import_mini69.z.boolean(),
   // New non-experimental options
-  global: (0, import_mini68.optional)(import_mini68.z.boolean()),
-  silent: (0, import_mini68.optional)(import_mini68.z.boolean()),
-  simulateCommands: (0, import_mini68.optional)(import_mini68.z.boolean()),
-  simulateSubagents: (0, import_mini68.optional)(import_mini68.z.boolean()),
-  simulateSkills: (0, import_mini68.optional)(import_mini68.z.boolean()),
-  dryRun: (0, import_mini68.optional)(import_mini68.z.boolean()),
-  check: (0, import_mini68.optional)(import_mini68.z.boolean()),
+  global: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  silent: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  simulateCommands: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  simulateSubagents: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  simulateSkills: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  dryRun: (0, import_mini69.optional)(import_mini69.z.boolean()),
+  check: (0, import_mini69.optional)(import_mini69.z.boolean()),
   // Declarative skill sources
-  sources: (0, import_mini68.optional)(import_mini68.z.array(SourceEntrySchema))
+  sources: (0, import_mini69.optional)(import_mini69.z.array(SourceEntrySchema))
 });
-var PartialConfigParamsSchema = import_mini68.z.partial(ConfigParamsSchema);
-var ConfigFileSchema = import_mini68.z.object({
-  $schema: (0, import_mini68.optional)(import_mini68.z.string()),
-  ...import_mini68.z.partial(ConfigParamsSchema).shape
+var PartialConfigParamsSchema = import_mini69.z.partial(ConfigParamsSchema);
+var ConfigFileSchema = import_mini69.z.object({
+  $schema: (0, import_mini69.optional)(import_mini69.z.string()),
+  ...import_mini69.z.partial(ConfigParamsSchema).shape
 });
-var RequiredConfigParamsSchema = import_mini68.z.required(ConfigParamsSchema);
+var RequiredConfigParamsSchema = import_mini69.z.required(ConfigParamsSchema);
 var CONFLICTING_TARGET_PAIRS = [
   ["augmentcode", "augmentcode-legacy"],
   ["claudecode", "claudecode-legacy"]
 ];
 var LEGACY_TARGETS = ["augmentcode-legacy", "claudecode-legacy"];
-var Config = class {
+var Config = class _Config {
   baseDirs;
   targets;
   features;
@@ -19985,26 +20026,23 @@ var Config = class {
       const perTargetFeatures = this.features;
       if (target) {
         const targetFeatures = perTargetFeatures[target];
-        if (!targetFeatures || targetFeatures.length === 0) {
+        if (!targetFeatures) {
           return [];
         }
-        if (targetFeatures.includes("*")) {
-          return [...ALL_FEATURES];
-        }
-        return targetFeatures.filter((feature) => feature !== "*");
+        return _Config.normalizeTargetFeatures(targetFeatures);
       }
       const allFeatures = [];
       for (const features of Object.values(perTargetFeatures)) {
-        if (features && features.length > 0) {
-          if (features.includes("*")) {
-            return [...ALL_FEATURES];
-          }
-          for (const feature of features) {
-            if (feature !== "*" && !allFeatures.includes(feature)) {
-              allFeatures.push(feature);
-            }
+        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;
     }
@@ -20014,19 +20052,60 @@ var Config = class {
     return this.features.filter((feature) => feature !== "*");
   }
   /**
-   * Check if per-target features configuration is being used.
+   * Normalize a per-target features value (array or per-feature object) into
+   * the flat list of enabled features.
    */
-  hasPerTargetFeatures() {
-    return !Array.isArray(this.features);
-  }
-  getVerbose() {
-    return this.verbose;
-  }
-  getDelete() {
-    return this.delete;
-  }
-  getGlobal() {
-    return this.global;
+  static normalizeTargetFeatures(value) {
+    if (Array.isArray(value)) {
+      if (value.length === 0) return [];
+      if (value.includes("*")) return [...ALL_FEATURES];
+      return value.filter((feature) => feature !== "*");
+    }
+    if (isFeatureValueEnabled(value["*"])) {
+      return [...ALL_FEATURES];
+    }
+    const enabled = [];
+    for (const [key, val] of Object.entries(value)) {
+      if (key === "*") continue;
+      if (!isFeatureValueEnabled(val)) continue;
+      enabled.push(key);
+    }
+    return enabled;
+  }
+  /**
+   * 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)) {
+      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;
+    }
+    return void 0;
+  }
+  /**
+   * Check if per-target features configuration is being used.
+   */
+  hasPerTargetFeatures() {
+    return !Array.isArray(this.features);
+  }
+  getVerbose() {
+    return this.verbose;
+  }
+  getDelete() {
+    return this.delete;
+  }
+  getGlobal() {
+    return this.global;
   }
   getSilent() {
     return this.silent;
@@ -20164,8 +20243,592 @@ function getBaseDirsInLightOfGlobal({
 }
 
 // src/lib/generate.ts
-var import_node_path135 = require("path");
+var import_node_path138 = require("path");
+var import_es_toolkit5 = require("es-toolkit");
+
+// src/features/permissions/permissions-processor.ts
+var import_mini72 = require("zod/mini");
+
+// src/features/permissions/claudecode-permissions.ts
+var import_node_path136 = require("path");
 var import_es_toolkit4 = require("es-toolkit");
+
+// src/features/permissions/rulesync-permissions.ts
+var import_node_path135 = require("path");
+
+// src/types/permissions.ts
+var import_mini70 = require("zod/mini");
+var PermissionActionSchema = import_mini70.z.enum(["allow", "ask", "deny"]);
+var PermissionRulesSchema = import_mini70.z.record(import_mini70.z.string(), PermissionActionSchema);
+var PermissionsConfigSchema = import_mini70.z.looseObject({
+  permission: import_mini70.z.record(import_mini70.z.string(), PermissionRulesSchema)
+});
+var RulesyncPermissionsFileSchema = import_mini70.z.looseObject({
+  $schema: import_mini70.z.optional(import_mini70.z.string()),
+  ...PermissionsConfigSchema.shape
+});
+
+// src/features/permissions/rulesync-permissions.ts
+var RulesyncPermissions = class _RulesyncPermissions extends RulesyncFile {
+  json;
+  constructor(params) {
+    super({ ...params });
+    this.json = JSON.parse(this.fileContent);
+    if (params.validate) {
+      const result = this.validate();
+      if (!result.success) {
+        throw result.error;
+      }
+    }
+  }
+  static getSettablePaths() {
+    return {
+      relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+      relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME
+    };
+  }
+  validate() {
+    const result = RulesyncPermissionsFileSchema.safeParse(this.json);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    return { success: true, error: null };
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true
+  }) {
+    const paths = _RulesyncPermissions.getSettablePaths();
+    const filePath = (0, import_node_path135.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    if (!await fileExists(filePath)) {
+      throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} found.`);
+    }
+    const fileContent = await readFileContent(filePath);
+    return new _RulesyncPermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  getJson() {
+    return this.json;
+  }
+};
+
+// src/features/permissions/tool-permissions.ts
+var ToolPermissions = class extends ToolFile {
+  static getSettablePaths(_options) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static fromRulesyncPermissions(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  toRulesyncPermissionsDefault({
+    fileContent
+  }) {
+    return new RulesyncPermissions({
+      baseDir: this.baseDir,
+      relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
+      relativeFilePath: RULESYNC_PERMISSIONS_FILE_NAME,
+      fileContent
+    });
+  }
+  static async fromFile(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+  static forDeletion(_params) {
+    throw new Error("Please implement this method in the subclass.");
+  }
+};
+
+// src/features/permissions/claudecode-permissions.ts
+var CANONICAL_TO_CLAUDE_TOOL_NAMES = {
+  bash: "Bash",
+  read: "Read",
+  edit: "Edit",
+  write: "Write",
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  grep: "Grep",
+  glob: "Glob",
+  notebookedit: "NotebookEdit",
+  agent: "Agent"
+};
+var CLAUDE_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(
+  Object.entries(CANONICAL_TO_CLAUDE_TOOL_NAMES).map(([k, v]) => [v, k])
+);
+function toClaudeToolName(canonical) {
+  return CANONICAL_TO_CLAUDE_TOOL_NAMES[canonical] ?? canonical;
+}
+function toCanonicalToolName(claudeName) {
+  return CLAUDE_TO_CANONICAL_TOOL_NAMES[claudeName] ?? claudeName;
+}
+function parseClaudePermissionEntry(entry) {
+  const parenIndex = entry.indexOf("(");
+  if (parenIndex === -1) {
+    return { toolName: entry, pattern: "*" };
+  }
+  const toolName = entry.slice(0, parenIndex);
+  if (!entry.endsWith(")")) {
+    return { toolName, pattern: "*" };
+  }
+  const pattern = entry.slice(parenIndex + 1, -1);
+  return { toolName, pattern: pattern || "*" };
+}
+function buildClaudePermissionEntry(toolName, pattern) {
+  if (pattern === "*") {
+    return toolName;
+  }
+  return `${toolName}(${pattern})`;
+}
+var ClaudecodePermissions = class _ClaudecodePermissions extends ToolPermissions {
+  constructor(params) {
+    super({
+      ...params,
+      fileContent: params.fileContent ?? "{}"
+    });
+  }
+  isDeletable() {
+    return false;
+  }
+  static getSettablePaths() {
+    return {
+      relativeDirPath: ".claude",
+      relativeFilePath: "settings.json"
+    };
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true
+  }) {
+    const paths = _ClaudecodePermissions.getSettablePaths();
+    const filePath = (0, import_node_path136.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const fileContent = await readFileContentOrNull(filePath) ?? '{"permissions":{}}';
+    return new _ClaudecodePermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    logger: logger5
+  }) {
+    const paths = _ClaudecodePermissions.getSettablePaths();
+    const filePath = (0, import_node_path136.join)(baseDir, paths.relativeDirPath, paths.relativeFilePath);
+    const existingContent = await readOrInitializeFileContent(
+      filePath,
+      JSON.stringify({}, null, 2)
+    );
+    let settings;
+    try {
+      settings = JSON.parse(existingContent);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse existing Claude settings at ${filePath}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const config = rulesyncPermissions.getJson();
+    const { allow, ask, deny } = convertRulesyncToClaudePermissions(config);
+    const managedToolNames = new Set(
+      Object.keys(config.permission).map((category) => toClaudeToolName(category))
+    );
+    const existingPermissions = settings.permissions ?? {};
+    const preservedAllow = (existingPermissions.allow ?? []).filter(
+      (entry) => !managedToolNames.has(parseClaudePermissionEntry(entry).toolName)
+    );
+    const preservedAsk = (existingPermissions.ask ?? []).filter(
+      (entry) => !managedToolNames.has(parseClaudePermissionEntry(entry).toolName)
+    );
+    const preservedDeny = (existingPermissions.deny ?? []).filter(
+      (entry) => !managedToolNames.has(parseClaudePermissionEntry(entry).toolName)
+    );
+    if (logger5 && managedToolNames.has("Read")) {
+      const droppedReadDenyEntries = (existingPermissions.deny ?? []).filter((entry) => {
+        const { toolName } = parseClaudePermissionEntry(entry);
+        return toolName === "Read";
+      });
+      if (droppedReadDenyEntries.length > 0) {
+        logger5.warn(
+          `Permissions feature manages 'Read' tool and will overwrite ${droppedReadDenyEntries.length} existing Read deny entries (possibly from ignore feature). Permissions take precedence.`
+        );
+      }
+    }
+    const mergedPermissions = {
+      ...existingPermissions
+    };
+    const mergedAllow = (0, import_es_toolkit4.uniq)([...preservedAllow, ...allow].toSorted());
+    const mergedAsk = (0, import_es_toolkit4.uniq)([...preservedAsk, ...ask].toSorted());
+    const mergedDeny = (0, import_es_toolkit4.uniq)([...preservedDeny, ...deny].toSorted());
+    if (mergedAllow.length > 0) {
+      mergedPermissions.allow = mergedAllow;
+    } else {
+      delete mergedPermissions.allow;
+    }
+    if (mergedAsk.length > 0) {
+      mergedPermissions.ask = mergedAsk;
+    } else {
+      delete mergedPermissions.ask;
+    }
+    if (mergedDeny.length > 0) {
+      mergedPermissions.deny = mergedDeny;
+    } else {
+      delete mergedPermissions.deny;
+    }
+    const merged = { ...settings, permissions: mergedPermissions };
+    const fileContent = JSON.stringify(merged, null, 2);
+    return new _ClaudecodePermissions({
+      baseDir,
+      relativeDirPath: paths.relativeDirPath,
+      relativeFilePath: paths.relativeFilePath,
+      fileContent,
+      validate: true
+    });
+  }
+  toRulesyncPermissions() {
+    let settings;
+    try {
+      settings = JSON.parse(this.getFileContent());
+    } catch (error) {
+      throw new Error(
+        `Failed to parse Claude permissions content in ${(0, import_node_path136.join)(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`,
+        { cause: error }
+      );
+    }
+    const permissions = settings.permissions ?? {};
+    const config = convertClaudeToRulesyncPermissions({
+      allow: permissions.allow ?? [],
+      ask: permissions.ask ?? [],
+      deny: permissions.deny ?? []
+    });
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify(config, null, 2)
+    });
+  }
+  validate() {
+    return { success: true, error: null };
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _ClaudecodePermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify({ permissions: {} }, null, 2),
+      validate: false
+    });
+  }
+};
+function convertRulesyncToClaudePermissions(config) {
+  const allow = [];
+  const ask = [];
+  const deny = [];
+  for (const [category, rules] of Object.entries(config.permission)) {
+    const claudeToolName = toClaudeToolName(category);
+    for (const [pattern, action] of Object.entries(rules)) {
+      const entry = buildClaudePermissionEntry(claudeToolName, pattern);
+      switch (action) {
+        case "allow":
+          allow.push(entry);
+          break;
+        case "ask":
+          ask.push(entry);
+          break;
+        case "deny":
+          deny.push(entry);
+          break;
+      }
+    }
+  }
+  return { allow, ask, deny };
+}
+function convertClaudeToRulesyncPermissions(params) {
+  const permission = {};
+  const processEntries = (entries, action) => {
+    for (const entry of entries) {
+      const { toolName, pattern } = parseClaudePermissionEntry(entry);
+      const canonical = toCanonicalToolName(toolName);
+      if (!permission[canonical]) {
+        permission[canonical] = {};
+      }
+      permission[canonical][pattern] = action;
+    }
+  };
+  processEntries(params.allow, "allow");
+  processEntries(params.ask, "ask");
+  processEntries(params.deny, "deny");
+  return { permission };
+}
+
+// src/features/permissions/opencode-permissions.ts
+var import_node_path137 = require("path");
+var import_jsonc_parser5 = require("jsonc-parser");
+var import_mini71 = require("zod/mini");
+var OpencodePermissionSchema = import_mini71.z.union([
+  import_mini71.z.enum(["allow", "ask", "deny"]),
+  import_mini71.z.record(import_mini71.z.string(), import_mini71.z.enum(["allow", "ask", "deny"]))
+]);
+var OpencodePermissionsConfigSchema = import_mini71.z.looseObject({
+  permission: import_mini71.z.optional(import_mini71.z.record(import_mini71.z.string(), OpencodePermissionSchema))
+});
+var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
+  json;
+  constructor(params) {
+    super(params);
+    this.json = OpencodePermissionsConfigSchema.parse((0, import_jsonc_parser5.parse)(this.fileContent || "{}"));
+  }
+  getJson() {
+    return this.json;
+  }
+  isDeletable() {
+    return false;
+  }
+  static getSettablePaths({
+    global = false
+  } = {}) {
+    return global ? { relativeDirPath: (0, import_node_path137.join)(".config", "opencode"), relativeFilePath: "opencode.json" } : { relativeDirPath: ".", relativeFilePath: "opencode.json" };
+  }
+  static async fromFile({
+    baseDir = process.cwd(),
+    validate = true,
+    global = false
+  }) {
+    const basePaths = _OpencodePermissions.getSettablePaths({ global });
+    const jsonDir = (0, import_node_path137.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path137.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path137.join)(jsonDir, "opencode.json");
+    let fileContent = await readFileContentOrNull(jsoncPath);
+    let relativeFilePath = "opencode.jsonc";
+    if (!fileContent) {
+      fileContent = await readFileContentOrNull(jsonPath);
+      if (fileContent) {
+        relativeFilePath = "opencode.json";
+      }
+    }
+    const parsed = (0, import_jsonc_parser5.parse)(fileContent ?? "{}");
+    const nextJson = { ...parsed, permission: parsed.permission ?? {} };
+    return new _OpencodePermissions({
+      baseDir,
+      relativeDirPath: basePaths.relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify(nextJson, null, 2),
+      validate
+    });
+  }
+  static async fromRulesyncPermissions({
+    baseDir = process.cwd(),
+    rulesyncPermissions,
+    global = false
+  }) {
+    const basePaths = _OpencodePermissions.getSettablePaths({ global });
+    const jsonDir = (0, import_node_path137.join)(baseDir, basePaths.relativeDirPath);
+    const jsoncPath = (0, import_node_path137.join)(jsonDir, "opencode.jsonc");
+    const jsonPath = (0, import_node_path137.join)(jsonDir, "opencode.json");
+    let fileContent = await readFileContentOrNull(jsoncPath);
+    let relativeFilePath = "opencode.jsonc";
+    if (!fileContent) {
+      fileContent = await readFileContentOrNull(jsonPath);
+      if (fileContent) {
+        relativeFilePath = "opencode.json";
+      }
+    }
+    const parsed = (0, import_jsonc_parser5.parse)(fileContent ?? "{}");
+    const nextJson = {
+      ...parsed,
+      permission: rulesyncPermissions.getJson().permission
+    };
+    return new _OpencodePermissions({
+      baseDir,
+      relativeDirPath: basePaths.relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify(nextJson, null, 2),
+      validate: true
+    });
+  }
+  toRulesyncPermissions() {
+    const permission = this.normalizePermission(this.json.permission);
+    return this.toRulesyncPermissionsDefault({
+      fileContent: JSON.stringify({ permission }, null, 2)
+    });
+  }
+  validate() {
+    try {
+      const json = JSON.parse(this.fileContent || "{}");
+      const result = OpencodePermissionsConfigSchema.safeParse(json);
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+      return { success: true, error: null };
+    } catch (error) {
+      return {
+        success: false,
+        error: new Error(`Failed to parse OpenCode permissions JSON: ${formatError(error)}`)
+      };
+    }
+  }
+  static forDeletion({
+    baseDir = process.cwd(),
+    relativeDirPath,
+    relativeFilePath
+  }) {
+    return new _OpencodePermissions({
+      baseDir,
+      relativeDirPath,
+      relativeFilePath,
+      fileContent: JSON.stringify({ permission: {} }, null, 2),
+      validate: false
+    });
+  }
+  normalizePermission(permission) {
+    if (!permission) {
+      return {};
+    }
+    return Object.fromEntries(
+      Object.entries(permission).map(([tool, value]) => [
+        tool,
+        typeof value === "string" ? { "*": value } : value
+      ])
+    );
+  }
+};
+
+// src/features/permissions/permissions-processor.ts
+var permissionsProcessorToolTargetTuple = ["claudecode", "opencode"];
+var PermissionsProcessorToolTargetSchema = import_mini72.z.enum(permissionsProcessorToolTargetTuple);
+var toolPermissionsFactories = /* @__PURE__ */ new Map([
+  [
+    "claudecode",
+    {
+      class: ClaudecodePermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: false,
+        supportsImport: true
+      }
+    }
+  ],
+  [
+    "opencode",
+    {
+      class: OpencodePermissions,
+      meta: {
+        supportsProject: true,
+        supportsGlobal: true,
+        supportsImport: true
+      }
+    }
+  ]
+]);
+var PermissionsProcessor = class extends FeatureProcessor {
+  toolTarget;
+  global;
+  constructor({
+    baseDir = process.cwd(),
+    toolTarget,
+    global = false,
+    dryRun = false,
+    logger: logger5
+  }) {
+    super({ baseDir, dryRun, logger: logger5 });
+    const result = PermissionsProcessorToolTargetSchema.safeParse(toolTarget);
+    if (!result.success) {
+      throw new Error(
+        `Invalid tool target for PermissionsProcessor: ${toolTarget}. ${formatError(result.error)}`
+      );
+    }
+    this.toolTarget = result.data;
+    this.global = global;
+  }
+  async loadRulesyncFiles() {
+    try {
+      return [
+        await RulesyncPermissions.fromFile({
+          baseDir: process.cwd(),
+          validate: true
+        })
+      ];
+    } catch (error) {
+      this.logger.error(
+        `Failed to load Rulesync permissions file (${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH}): ${formatError(error)}`
+      );
+      return [];
+    }
+  }
+  async loadToolFiles({
+    forDeletion = false
+  } = {}) {
+    try {
+      const factory = toolPermissionsFactories.get(this.toolTarget);
+      if (!factory) throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+      const paths = factory.class.getSettablePaths({ global: this.global });
+      if (forDeletion) {
+        const toolPermissions2 = factory.class.forDeletion({
+          baseDir: this.baseDir,
+          relativeDirPath: paths.relativeDirPath,
+          relativeFilePath: paths.relativeFilePath,
+          global: this.global
+        });
+        const list = toolPermissions2.isDeletable?.() !== false ? [toolPermissions2] : [];
+        return list;
+      }
+      const toolPermissions = await factory.class.fromFile({
+        baseDir: this.baseDir,
+        validate: true,
+        global: this.global
+      });
+      return [toolPermissions];
+    } catch (error) {
+      const msg = `Failed to load permissions files for tool target: ${this.toolTarget}: ${formatError(error)}`;
+      if (error instanceof Error && error.message.includes("no such file or directory")) {
+        this.logger.debug(msg);
+      } else {
+        this.logger.error(msg);
+      }
+      return [];
+    }
+  }
+  async convertRulesyncFilesToToolFiles(rulesyncFiles) {
+    const rulesyncPermissions = rulesyncFiles.find(
+      (f) => f instanceof RulesyncPermissions
+    );
+    if (!rulesyncPermissions) {
+      throw new Error(`No ${RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH} found.`);
+    }
+    const factory = toolPermissionsFactories.get(this.toolTarget);
+    if (!factory) throw new Error(`Unsupported tool target: ${this.toolTarget}`);
+    const toolPermissions = await factory.class.fromRulesyncPermissions({
+      baseDir: this.baseDir,
+      rulesyncPermissions,
+      logger: this.logger,
+      global: this.global
+    });
+    return [toolPermissions];
+  }
+  async convertToolFilesToRulesyncFiles(toolFiles) {
+    const permissions = toolFiles.filter((f) => f instanceof ToolPermissions);
+    return permissions.map((p) => p.toRulesyncPermissions());
+  }
+  static getToolTargets({
+    global = false,
+    importOnly = false
+  } = {}) {
+    return [...toolPermissionsFactories.entries()].filter(([, f]) => global ? f.meta.supportsGlobal : f.meta.supportsProject).filter(([, f]) => importOnly ? f.meta.supportsImport : true).map(([target]) => target);
+  }
+};
+
+// src/lib/generate.ts
 async function processFeatureGeneration(params) {
   const { config, processor, toolFiles } = params;
   let totalCount = 0;
@@ -20238,7 +20901,7 @@ function warnUnsupportedTargets(params) {
   }
 }
 async function checkRulesyncDirExists(params) {
-  return fileExists((0, import_node_path135.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
+  return fileExists((0, import_node_path138.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
 }
 async function generate(params) {
   const { config, logger: logger5 } = params;
@@ -20248,8 +20911,9 @@ async function generate(params) {
   const subagentsResult = await generateSubagentsCore({ config, logger: logger5 });
   const skillsResult = await generateSkillsCore({ config, logger: logger5 });
   const hooksResult = await generateHooksCore({ config, logger: logger5 });
+  const permissionsResult = await generatePermissionsCore({ config, logger: logger5 });
   const rulesResult = await generateRulesCore({ config, logger: logger5, skills: skillsResult.skills });
-  const hasDiff = ignoreResult.hasDiff || mcpResult.hasDiff || commandsResult.hasDiff || subagentsResult.hasDiff || skillsResult.hasDiff || hooksResult.hasDiff || rulesResult.hasDiff;
+  const hasDiff = ignoreResult.hasDiff || mcpResult.hasDiff || commandsResult.hasDiff || subagentsResult.hasDiff || skillsResult.hasDiff || hooksResult.hasDiff || permissionsResult.hasDiff || rulesResult.hasDiff;
   return {
     rulesCount: rulesResult.count,
     rulesPaths: rulesResult.paths,
@@ -20265,6 +20929,8 @@ async function generate(params) {
     skillsPaths: skillsResult.paths,
     hooksCount: hooksResult.count,
     hooksPaths: hooksResult.paths,
+    permissionsCount: permissionsResult.count,
+    permissionsPaths: permissionsResult.paths,
     skills: skillsResult.skills,
     hasDiff
   };
@@ -20275,7 +20941,7 @@ async function generateRulesCore(params) {
   const allPaths = [];
   let hasDiff = false;
   const supportedTargets = RulesProcessor.getToolTargets({ global: config.getGlobal() });
-  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedTargets);
+  const toolTargets = (0, import_es_toolkit5.intersection)(config.getTargets(), supportedTargets);
   warnUnsupportedTargets({ config, supportedTargets, featureName: "rules", logger: logger5 });
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
@@ -20317,7 +20983,7 @@ async function generateIgnoreCore(params) {
   let totalCount = 0;
   const allPaths = [];
   let hasDiff = false;
-  for (const toolTarget of (0, import_es_toolkit4.intersection)(config.getTargets(), supportedIgnoreTargets)) {
+  for (const toolTarget of (0, import_es_toolkit5.intersection)(config.getTargets(), supportedIgnoreTargets)) {
     if (!config.getFeatures(toolTarget).includes("ignore")) {
       continue;
     }
@@ -20327,7 +20993,8 @@ async function generateIgnoreCore(params) {
           baseDir: baseDir === process.cwd() ? "." : baseDir,
           toolTarget,
           dryRun: config.isPreviewMode(),
-          logger: logger5
+          logger: logger5,
+          featureOptions: config.getFeatureOptions(toolTarget, "ignore")
         });
         const rulesyncFiles = await processor.loadRulesyncFiles();
         const result = await processFeatureWithRulesyncFiles({ config, processor, rulesyncFiles });
@@ -20350,7 +21017,7 @@ async function generateMcpCore(params) {
   const allPaths = [];
   let hasDiff = false;
   const supportedMcpTargets = McpProcessor.getToolTargets({ global: config.getGlobal() });
-  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedMcpTargets);
+  const toolTargets = (0, import_es_toolkit5.intersection)(config.getTargets(), supportedMcpTargets);
   warnUnsupportedTargets({
     config,
     supportedTargets: supportedMcpTargets,
@@ -20387,7 +21054,7 @@ async function generateCommandsCore(params) {
     global: config.getGlobal(),
     includeSimulated: config.getSimulateCommands()
   });
-  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedCommandsTargets);
+  const toolTargets = (0, import_es_toolkit5.intersection)(config.getTargets(), supportedCommandsTargets);
   warnUnsupportedTargets({
     config,
     supportedTargets: supportedCommandsTargets,
@@ -20425,7 +21092,7 @@ async function generateSubagentsCore(params) {
     global: config.getGlobal(),
     includeSimulated: config.getSimulateSubagents()
   });
-  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedSubagentsTargets);
+  const toolTargets = (0, import_es_toolkit5.intersection)(config.getTargets(), supportedSubagentsTargets);
   warnUnsupportedTargets({
     config,
     supportedTargets: supportedSubagentsTargets,
@@ -20464,7 +21131,7 @@ async function generateSkillsCore(params) {
     global: config.getGlobal(),
     includeSimulated: config.getSimulateSkills()
   });
-  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedSkillsTargets);
+  const toolTargets = (0, import_es_toolkit5.intersection)(config.getTargets(), supportedSkillsTargets);
   warnUnsupportedTargets({
     config,
     supportedTargets: supportedSkillsTargets,
@@ -20509,7 +21176,7 @@ async function generateHooksCore(params) {
   const allPaths = [];
   let hasDiff = false;
   const supportedHooksTargets = HooksProcessor.getToolTargets({ global: config.getGlobal() });
-  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedHooksTargets);
+  const toolTargets = (0, import_es_toolkit5.intersection)(config.getTargets(), supportedHooksTargets);
   warnUnsupportedTargets({
     config,
     supportedTargets: supportedHooksTargets,
@@ -20537,10 +21204,52 @@ async function generateHooksCore(params) {
   }
   return { count: totalCount, paths: allPaths, hasDiff };
 }
+async function generatePermissionsCore(params) {
+  const { config, logger: logger5 } = params;
+  const supportedPermissionsTargets = PermissionsProcessor.getToolTargets({
+    global: config.getGlobal()
+  });
+  warnUnsupportedTargets({
+    config,
+    supportedTargets: supportedPermissionsTargets,
+    featureName: "permissions",
+    logger: logger5
+  });
+  let totalCount = 0;
+  const allPaths = [];
+  let hasDiff = false;
+  for (const baseDir of config.getBaseDirs()) {
+    for (const toolTarget of (0, import_es_toolkit5.intersection)(config.getTargets(), supportedPermissionsTargets)) {
+      if (!config.getFeatures(toolTarget).includes("permissions")) {
+        continue;
+      }
+      try {
+        const processor = new PermissionsProcessor({
+          baseDir,
+          toolTarget,
+          global: config.getGlobal(),
+          dryRun: config.isPreviewMode(),
+          logger: logger5
+        });
+        const rulesyncFiles = await processor.loadRulesyncFiles();
+        const result = await processFeatureWithRulesyncFiles({ config, processor, rulesyncFiles });
+        totalCount += result.count;
+        allPaths.push(...result.paths);
+        if (result.hasDiff) hasDiff = true;
+      } catch (error) {
+        logger5.warn(
+          `Failed to generate ${toolTarget} permissions files for ${baseDir}: ${formatError(error)}`
+        );
+        continue;
+      }
+    }
+  }
+  return { count: totalCount, paths: allPaths, hasDiff };
+}
 
 // src/utils/result.ts
 function calculateTotalCount(result) {
-  return result.rulesCount + result.ignoreCount + result.mcpCount + result.commandsCount + result.subagentsCount + result.skillsCount + result.hooksCount;
+  return result.rulesCount + result.ignoreCount + result.mcpCount + result.commandsCount + result.subagentsCount + result.skillsCount + result.hooksCount + result.permissionsCount;
 }
 
 // src/cli/commands/generate.ts
@@ -20601,6 +21310,7 @@ async function generateCommand(logger5, options) {
     subagents: { count: result.subagentsCount, paths: result.subagentsPaths },
     skills: { count: result.skillsCount, paths: result.skillsPaths },
     hooks: { count: result.hooksCount, paths: result.hooksPaths },
+    permissions: { count: result.permissionsCount, paths: result.permissionsPaths },
     rules: { count: result.rulesCount, paths: result.rulesPaths }
   };
   const featureLabels = {
@@ -20610,7 +21320,8 @@ async function generateCommand(logger5, options) {
     commands: (count) => `${count === 1 ? "command" : "commands"}`,
     subagents: (count) => `${count === 1 ? "subagent" : "subagents"}`,
     skills: (count) => `${count === 1 ? "skill" : "skills"}`,
-    hooks: (count) => `${count === 1 ? "hooks file" : "hooks files"}`
+    hooks: (count) => `${count === 1 ? "hooks file" : "hooks files"}`,
+    permissions: (count) => `${count === 1 ? "permissions file" : "permissions files"}`
   };
   for (const [feature, data] of Object.entries(featureResults)) {
     logFeatureResult(logger5, {
@@ -20650,6 +21361,7 @@ async function generateCommand(logger5, options) {
   if (result.subagentsCount > 0) parts.push(`${result.subagentsCount} subagents`);
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
+  if (result.permissionsCount > 0) parts.push(`${result.permissionsCount} permissions`);
   if (isPreview) {
     logger5.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   } else {
@@ -20658,7 +21370,7 @@ async function generateCommand(logger5, options) {
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_path136 = require("path");
+var import_node_path139 = require("path");
 
 // src/cli/commands/gitignore-entries.ts
 var normalizeGitignoreEntryTargets = (target) => {
@@ -20673,7 +21385,6 @@ var GITIGNORE_ENTRY_REGISTRY = [
   },
   { target: "common", feature: "general", entry: ".rulesync/rules/*.local.md" },
   { target: "common", feature: "general", entry: "rulesync.local.jsonc" },
-  { target: "common", feature: "general", entry: "!.rulesync/.aiignore" },
   // AGENTS.local.md is placed in common scope (not rovodev-only) so that
   // local rule files are always gitignored regardless of which targets are enabled.
   // This prevents accidental commits when a user disables the rovodev target.
@@ -20805,6 +21516,8 @@ var GITIGNORE_ENTRY_REGISTRY = [
   { target: "kiro", feature: "subagents", entry: "**/.kiro/agents/" },
   { target: "kiro", feature: "mcp", entry: "**/.kiro/settings/mcp.json" },
   { target: "kiro", feature: "ignore", entry: "**/.aiignore" },
+  // Keep this after ignore entries like "**/.aiignore" so the exception remains effective.
+  { target: "common", feature: "general", entry: "!.rulesync/.aiignore" },
   // OpenCode
   { target: "opencode", feature: "commands", entry: "**/.opencode/command/" },
   { target: "opencode", feature: "subagents", entry: "**/.opencode/agent/" },
@@ -20869,8 +21582,12 @@ var isFeatureSelectedForTarget = (feature, target, features) => {
   if (target === "common") return true;
   const targetFeatures = features[target];
   if (!targetFeatures) return true;
-  if (targetFeatures.includes("*")) return true;
-  return targetFeatures.includes(feature);
+  if (Array.isArray(targetFeatures)) {
+    if (targetFeatures.includes("*")) return true;
+    return targetFeatures.includes(feature);
+  }
+  if (isFeatureValueEnabled(targetFeatures["*"])) return true;
+  return isFeatureValueEnabled(targetFeatures[feature]);
 };
 var isFeatureSelected = (feature, target, features) => {
   return normalizeGitignoreEntryTargets(target).some(
@@ -20905,8 +21622,14 @@ var warnInvalidFeatures = (features, logger5) => {
   } else {
     for (const targetFeatures of Object.values(features)) {
       if (!targetFeatures) continue;
-      for (const feature of targetFeatures) {
-        warnOnce(feature);
+      if (Array.isArray(targetFeatures)) {
+        for (const feature of targetFeatures) {
+          warnOnce(feature);
+        }
+      } else {
+        for (const feature of Object.keys(targetFeatures)) {
+          warnOnce(feature);
+        }
       }
     }
   }
@@ -20985,7 +21708,7 @@ var removeExistingRulesyncEntries = (content) => {
   return result;
 };
 var gitignoreCommand = async (logger5, options) => {
-  const gitignorePath = (0, import_node_path136.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path139.join)(process.cwd(), ".gitignore");
   let gitignoreContent = "";
   if (await fileExists(gitignorePath)) {
     gitignoreContent = await readFileContent(gitignorePath);
@@ -21047,6 +21770,7 @@ async function importFromTool(params) {
   const subagentsCount = await importSubagentsCore({ config, tool, logger: logger5 });
   const skillsCount = await importSkillsCore({ config, tool, logger: logger5 });
   const hooksCount = await importHooksCore({ config, tool, logger: logger5 });
+  const permissionsCount = await importPermissionsCore({ config, tool, logger: logger5 });
   return {
     rulesCount,
     ignoreCount,
@@ -21054,7 +21778,8 @@ async function importFromTool(params) {
     commandsCount,
     subagentsCount,
     skillsCount,
-    hooksCount
+    hooksCount,
+    permissionsCount
   };
 }
 async function importRulesCore(params) {
@@ -21100,7 +21825,8 @@ async function importIgnoreCore(params) {
   const ignoreProcessor = new IgnoreProcessor({
     baseDir: config.getBaseDirs()[0] ?? ".",
     toolTarget: tool,
-    logger: logger5
+    logger: logger5,
+    featureOptions: config.getFeatureOptions(tool, "ignore")
   });
   const toolFiles = await ignoreProcessor.loadToolFiles();
   if (toolFiles.length === 0) {
@@ -21262,6 +21988,41 @@ async function importHooksCore(params) {
   }
   return writtenCount;
 }
+async function importPermissionsCore(params) {
+  const { config, tool, logger: logger5 } = params;
+  if (!config.getFeatures(tool).includes("permissions")) {
+    return 0;
+  }
+  const allTargets = PermissionsProcessor.getToolTargets({ global: config.getGlobal() });
+  const importableTargets = PermissionsProcessor.getToolTargets({
+    global: config.getGlobal(),
+    importOnly: true
+  });
+  if (!allTargets.includes(tool)) {
+    return 0;
+  }
+  if (!importableTargets.includes(tool)) {
+    logger5.warn(`Import is not supported for ${tool} permissions. Skipping.`);
+    return 0;
+  }
+  const permissionsProcessor = new PermissionsProcessor({
+    baseDir: config.getBaseDirs()[0] ?? ".",
+    toolTarget: tool,
+    global: config.getGlobal(),
+    logger: logger5
+  });
+  const toolFiles = await permissionsProcessor.loadToolFiles();
+  if (toolFiles.length === 0) {
+    logger5.warn(`No permissions files found for ${tool}. Skipping import.`);
+    return 0;
+  }
+  const rulesyncFiles = await permissionsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
+  const { count: writtenCount } = await permissionsProcessor.writeAiFiles(rulesyncFiles);
+  if (config.getVerbose() && writtenCount > 0) {
+    logger5.success(`Created ${writtenCount} permissions file(s)`);
+  }
+  return writtenCount;
+}
 
 // src/cli/commands/import.ts
 async function importCommand(logger5, options) {
@@ -21290,7 +22051,8 @@ async function importCommand(logger5, options) {
       commands: { count: result.commandsCount },
       subagents: { count: result.subagentsCount },
       skills: { count: result.skillsCount },
-      hooks: { count: result.hooksCount }
+      hooks: { count: result.hooksCount },
+      permissions: { count: result.permissionsCount }
     });
     logger5.captureData("totalFiles", totalImported);
   }
@@ -21302,11 +22064,12 @@ async function importCommand(logger5, options) {
   if (result.subagentsCount > 0) parts.push(`${result.subagentsCount} subagents`);
   if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
   if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
+  if (result.permissionsCount > 0) parts.push(`${result.permissionsCount} permissions`);
   logger5.success(`Imported ${totalImported} file(s) total (${parts.join(" + ")})`);
 }
 
 // src/lib/init.ts
-var import_node_path137 = require("path");
+var import_node_path140 = require("path");
 async function init() {
   const sampleFiles = await createSampleFiles();
   const configFile = await createConfigFile();
@@ -21498,27 +22261,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_path137.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
+  const ruleFilepath = (0, import_node_path140.join)(rulePaths.recommended.relativeDirPath, sampleRuleFile.filename);
   results.push(await writeIfNotExists(ruleFilepath, sampleRuleFile.content));
-  const mcpFilepath = (0, import_node_path137.join)(
+  const mcpFilepath = (0, import_node_path140.join)(
     mcpPaths.recommended.relativeDirPath,
     mcpPaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(mcpFilepath, sampleMcpFile.content));
-  const commandFilepath = (0, import_node_path137.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
+  const commandFilepath = (0, import_node_path140.join)(commandPaths.relativeDirPath, sampleCommandFile.filename);
   results.push(await writeIfNotExists(commandFilepath, sampleCommandFile.content));
-  const subagentFilepath = (0, import_node_path137.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
+  const subagentFilepath = (0, import_node_path140.join)(subagentPaths.relativeDirPath, sampleSubagentFile.filename);
   results.push(await writeIfNotExists(subagentFilepath, sampleSubagentFile.content));
-  const skillDirPath = (0, import_node_path137.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
+  const skillDirPath = (0, import_node_path140.join)(skillPaths.relativeDirPath, sampleSkillFile.dirName);
   await ensureDir(skillDirPath);
-  const skillFilepath = (0, import_node_path137.join)(skillDirPath, SKILL_FILE_NAME);
+  const skillFilepath = (0, import_node_path140.join)(skillDirPath, SKILL_FILE_NAME);
   results.push(await writeIfNotExists(skillFilepath, sampleSkillFile.content));
-  const ignoreFilepath = (0, import_node_path137.join)(
+  const ignoreFilepath = (0, import_node_path140.join)(
     ignorePaths.recommended.relativeDirPath,
     ignorePaths.recommended.relativeFilePath
   );
   results.push(await writeIfNotExists(ignoreFilepath, sampleIgnoreFile.content));
-  const hooksFilepath = (0, import_node_path137.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
+  const hooksFilepath = (0, import_node_path140.join)(hooksPaths.relativeDirPath, hooksPaths.relativeFilePath);
   results.push(await writeIfNotExists(hooksFilepath, sampleHooksFile.content));
   return results;
 }
@@ -21566,12 +22329,12 @@ async function initCommand(logger5) {
 }
 
 // src/lib/sources.ts
-var import_node_path140 = require("path");
+var import_node_path143 = 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_path138 = require("path");
+var import_node_path141 = 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;
@@ -21659,7 +22422,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_path138.isAbsolute)(skillsPath)) {
+  if (skillsPath.split(/[/\\]/).includes("..") || (0, import_node_path141.isAbsolute)(skillsPath)) {
     throw new GitClientError(
       `Invalid skillsPath "${skillsPath}": must be a relative path without ".."`
     );
@@ -21693,7 +22456,7 @@ async function fetchSkillFiles(params) {
       timeout: GIT_TIMEOUT_MS
     });
     await execFileAsync("git", ["-C", tmpDir, "checkout"], { timeout: GIT_TIMEOUT_MS });
-    const skillsDir = (0, import_node_path138.join)(tmpDir, skillsPath);
+    const skillsDir = (0, import_node_path141.join)(tmpDir, skillsPath);
     if (!await directoryExists(skillsDir)) return [];
     return await walkDirectory(skillsDir, skillsDir, 0, { totalFiles: 0, totalSize: 0 }, logger5);
   } catch (error) {
@@ -21715,7 +22478,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_path138.join)(dir, name);
+    const fullPath = (0, import_node_path141.join)(dir, name);
     if (await isSymlink(fullPath)) {
       logger5?.warn(`Skipping symlink "${fullPath}".`);
       continue;
@@ -21743,7 +22506,7 @@ async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, tot
         );
       }
       const content = await readFileContent(fullPath);
-      results.push({ relativePath: (0, import_node_path138.relative)(baseDir, fullPath), content, size });
+      results.push({ relativePath: (0, import_node_path141.relative)(baseDir, fullPath), content, size });
     }
   }
   return results;
@@ -21751,28 +22514,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_path139 = require("path");
-var import_mini69 = require("zod/mini");
+var import_node_path142 = require("path");
+var import_mini73 = require("zod/mini");
 var LOCKFILE_VERSION = 1;
-var LockedSkillSchema = import_mini69.z.object({
-  integrity: import_mini69.z.string()
+var LockedSkillSchema = import_mini73.z.object({
+  integrity: import_mini73.z.string()
 });
-var LockedSourceSchema = import_mini69.z.object({
-  requestedRef: (0, import_mini69.optional)(import_mini69.z.string()),
-  resolvedRef: import_mini69.z.string().check((0, import_mini69.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
-  resolvedAt: (0, import_mini69.optional)(import_mini69.z.string()),
-  skills: import_mini69.z.record(import_mini69.z.string(), LockedSkillSchema)
+var LockedSourceSchema = import_mini73.z.object({
+  requestedRef: (0, import_mini73.optional)(import_mini73.z.string()),
+  resolvedRef: import_mini73.z.string().check((0, import_mini73.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
+  resolvedAt: (0, import_mini73.optional)(import_mini73.z.string()),
+  skills: import_mini73.z.record(import_mini73.z.string(), LockedSkillSchema)
 });
-var SourcesLockSchema = import_mini69.z.object({
-  lockfileVersion: import_mini69.z.number(),
-  sources: import_mini69.z.record(import_mini69.z.string(), LockedSourceSchema)
+var SourcesLockSchema = import_mini73.z.object({
+  lockfileVersion: import_mini73.z.number(),
+  sources: import_mini73.z.record(import_mini73.z.string(), LockedSourceSchema)
 });
-var LegacyLockedSourceSchema = import_mini69.z.object({
-  resolvedRef: import_mini69.z.string(),
-  skills: import_mini69.z.array(import_mini69.z.string())
+var LegacyLockedSourceSchema = import_mini73.z.object({
+  resolvedRef: import_mini73.z.string(),
+  skills: import_mini73.z.array(import_mini73.z.string())
 });
-var LegacySourcesLockSchema = import_mini69.z.object({
-  sources: import_mini69.z.record(import_mini69.z.string(), LegacyLockedSourceSchema)
+var LegacySourcesLockSchema = import_mini73.z.object({
+  sources: import_mini73.z.record(import_mini73.z.string(), LegacyLockedSourceSchema)
 });
 function migrateLegacyLock(params) {
   const { legacy, logger: logger5 } = params;
@@ -21797,7 +22560,7 @@ function createEmptyLock() {
 }
 async function readLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path139.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path142.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
   if (!await fileExists(lockPath)) {
     logger5.debug("No sources lockfile found, starting fresh.");
     return createEmptyLock();
@@ -21826,7 +22589,7 @@ async function readLockFile(params) {
 }
 async function writeLockFile(params) {
   const { logger: logger5 } = params;
-  const lockPath = (0, import_node_path139.join)(params.baseDir, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH);
+  const lockPath = (0, import_node_path142.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}`);
@@ -22000,7 +22763,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_path140.join)(curatedDir, name))) {
+    if (!await directoryExists((0, import_node_path143.join)(curatedDir, name))) {
       return false;
     }
   }
@@ -22008,10 +22771,10 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
 }
 async function cleanPreviousCuratedSkills(params) {
   const { curatedDir, lockedSkillNames, logger: logger5 } = params;
-  const resolvedCuratedDir = (0, import_node_path140.resolve)(curatedDir);
+  const resolvedCuratedDir = (0, import_node_path143.resolve)(curatedDir);
   for (const prevSkill of lockedSkillNames) {
-    const prevDir = (0, import_node_path140.join)(curatedDir, prevSkill);
-    if (!(0, import_node_path140.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path140.sep)) {
+    const prevDir = (0, import_node_path143.join)(curatedDir, prevSkill);
+    if (!(0, import_node_path143.resolve)(prevDir).startsWith(resolvedCuratedDir + import_node_path143.sep)) {
       logger5.warn(
         `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
       );
@@ -22050,9 +22813,9 @@ async function writeSkillAndComputeIntegrity(params) {
   for (const file of files) {
     checkPathTraversal({
       relativePath: file.relativePath,
-      intendedRootDir: (0, import_node_path140.join)(curatedDir, skillName)
+      intendedRootDir: (0, import_node_path143.join)(curatedDir, skillName)
     });
-    await writeFileContent((0, import_node_path140.join)(curatedDir, skillName, file.relativePath), file.content);
+    await writeFileContent((0, import_node_path143.join)(curatedDir, skillName, file.relativePath), file.content);
     written.push({ path: file.relativePath, content: file.content });
   }
   const integrity = computeSkillIntegrity(written);
@@ -22129,7 +22892,7 @@ async function fetchSource(params) {
     ref = resolvedSha;
     logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
   }
-  const curatedDir = (0, import_node_path140.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path143.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
     if (allExist) {
@@ -22254,7 +23017,7 @@ async function fetchSourceViaGit(params) {
     requestedRef = def.ref;
     resolvedSha = def.sha;
   }
-  const curatedDir = (0, import_node_path140.join)(baseDir, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
+  const curatedDir = (0, import_node_path143.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 };
@@ -22370,11 +23133,11 @@ async function installCommand(logger5, options) {
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini78 = require("zod/mini");
+var import_mini82 = require("zod/mini");
 
 // src/mcp/commands.ts
-var import_node_path141 = require("path");
-var import_mini70 = require("zod/mini");
+var import_node_path144 = require("path");
+var import_mini74 = require("zod/mini");
 
 // src/utils/logger.ts
 var BaseLogger = class {
@@ -22525,7 +23288,7 @@ var logger = new ConsoleLogger({ verbose: false, silent: true });
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
 async function listCommands() {
-  const commandsDir = (0, import_node_path141.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+  const commandsDir = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(commandsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -22541,7 +23304,7 @@ async function listCommands() {
           });
           const frontmatter = command.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path141.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -22563,13 +23326,13 @@ async function getCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path141.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
   try {
     const command = await RulesyncCommand.fromFile({
       relativeFilePath: filename
     });
     return {
-      relativePathFromCwd: (0, import_node_path141.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -22588,7 +23351,7 @@ async function putCommand({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path141.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxCommandSizeBytes) {
     throw new Error(
@@ -22598,7 +23361,7 @@ async function putCommand({
   try {
     const existingCommands = await listCommands();
     const isUpdate = existingCommands.some(
-      (command2) => command2.relativePathFromCwd === (0, import_node_path141.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      (command2) => command2.relativePathFromCwd === (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingCommands.length >= maxCommandsCount) {
       throw new Error(
@@ -22615,11 +23378,11 @@ async function putCommand({
       fileContent,
       validate: true
     });
-    const commandsDir = (0, import_node_path141.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
+    const commandsDir = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH);
     await ensureDir(commandsDir);
     await writeFileContent(command.getFilePath(), command.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path141.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename),
       frontmatter: command.getFrontmatter(),
       body: command.getBody()
     };
@@ -22634,12 +23397,12 @@ async function deleteCommand({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path141.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path141.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path144.join)(process.cwd(), RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path141.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete command file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -22648,23 +23411,23 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini70.z.object({}),
-  getCommand: import_mini70.z.object({
-    relativePathFromCwd: import_mini70.z.string()
+  listCommands: import_mini74.z.object({}),
+  getCommand: import_mini74.z.object({
+    relativePathFromCwd: import_mini74.z.string()
   }),
-  putCommand: import_mini70.z.object({
-    relativePathFromCwd: import_mini70.z.string(),
+  putCommand: import_mini74.z.object({
+    relativePathFromCwd: import_mini74.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini70.z.string()
+    body: import_mini74.z.string()
   }),
-  deleteCommand: import_mini70.z.object({
-    relativePathFromCwd: import_mini70.z.string()
+  deleteCommand: import_mini74.z.object({
+    relativePathFromCwd: import_mini74.z.string()
   })
 };
 var commandTools = {
   listCommands: {
     name: "listCommands",
-    description: `List all commands from ${(0, import_node_path141.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all commands from ${(0, import_node_path144.join)(RULESYNC_COMMANDS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: commandToolSchemas.listCommands,
     execute: async () => {
       const commands = await listCommands();
@@ -22706,15 +23469,15 @@ var commandTools = {
 };
 
 // src/mcp/generate.ts
-var import_mini71 = require("zod/mini");
-var generateOptionsSchema = import_mini71.z.object({
-  targets: import_mini71.z.optional(import_mini71.z.array(import_mini71.z.string())),
-  features: import_mini71.z.optional(import_mini71.z.array(import_mini71.z.string())),
-  delete: import_mini71.z.optional(import_mini71.z.boolean()),
-  global: import_mini71.z.optional(import_mini71.z.boolean()),
-  simulateCommands: import_mini71.z.optional(import_mini71.z.boolean()),
-  simulateSubagents: import_mini71.z.optional(import_mini71.z.boolean()),
-  simulateSkills: import_mini71.z.optional(import_mini71.z.boolean())
+var import_mini75 = require("zod/mini");
+var generateOptionsSchema = import_mini75.z.object({
+  targets: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string())),
+  features: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string())),
+  delete: import_mini75.z.optional(import_mini75.z.boolean()),
+  global: import_mini75.z.optional(import_mini75.z.boolean()),
+  simulateCommands: import_mini75.z.optional(import_mini75.z.boolean()),
+  simulateSubagents: import_mini75.z.optional(import_mini75.z.boolean()),
+  simulateSkills: import_mini75.z.optional(import_mini75.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -22763,6 +23526,7 @@ function buildSuccessResponse(params) {
       subagentsCount: generateResult.subagentsCount,
       skillsCount: generateResult.skillsCount,
       hooksCount: generateResult.hooksCount,
+      permissionsCount: generateResult.permissionsCount,
       totalCount
     },
     config: {
@@ -22792,11 +23556,11 @@ var generateTools = {
 };
 
 // src/mcp/ignore.ts
-var import_node_path142 = require("path");
-var import_mini72 = require("zod/mini");
+var import_node_path145 = require("path");
+var import_mini76 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
-  const ignoreFilePath = (0, import_node_path142.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   try {
     const content = await readFileContent(ignoreFilePath);
     return {
@@ -22813,7 +23577,7 @@ async function getIgnoreFile() {
   }
 }
 async function putIgnoreFile({ content }) {
-  const ignoreFilePath = (0, import_node_path142.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const ignoreFilePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
   const contentSizeBytes = Buffer.byteLength(content, "utf8");
   if (contentSizeBytes > maxIgnoreFileSizeBytes) {
     throw new Error(
@@ -22837,8 +23601,8 @@ async function putIgnoreFile({ content }) {
   }
 }
 async function deleteIgnoreFile() {
-  const aiignorePath = (0, import_node_path142.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
-  const legacyIgnorePath = (0, import_node_path142.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
+  const aiignorePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
+  const legacyIgnorePath = (0, import_node_path145.join)(process.cwd(), RULESYNC_IGNORE_RELATIVE_FILE_PATH);
   try {
     await Promise.all([removeFile(aiignorePath), removeFile(legacyIgnorePath)]);
     return {
@@ -22856,11 +23620,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini72.z.object({}),
-  putIgnoreFile: import_mini72.z.object({
-    content: import_mini72.z.string()
+  getIgnoreFile: import_mini76.z.object({}),
+  putIgnoreFile: import_mini76.z.object({
+    content: import_mini76.z.string()
   }),
-  deleteIgnoreFile: import_mini72.z.object({})
+  deleteIgnoreFile: import_mini76.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -22893,11 +23657,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-var import_mini73 = require("zod/mini");
-var importOptionsSchema = import_mini73.z.object({
-  target: import_mini73.z.string(),
-  features: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string())),
-  global: import_mini73.z.optional(import_mini73.z.boolean())
+var import_mini77 = require("zod/mini");
+var importOptionsSchema = import_mini77.z.object({
+  target: import_mini77.z.string(),
+  features: import_mini77.z.optional(import_mini77.z.array(import_mini77.z.string())),
+  global: import_mini77.z.optional(import_mini77.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -22942,6 +23706,7 @@ function buildSuccessResponse2(params) {
       subagentsCount: importResult.subagentsCount,
       skillsCount: importResult.skillsCount,
       hooksCount: importResult.hooksCount,
+      permissionsCount: importResult.permissionsCount,
       totalCount
     },
     config: {
@@ -22967,15 +23732,15 @@ var importTools = {
 };
 
 // src/mcp/mcp.ts
-var import_node_path143 = require("path");
-var import_mini74 = require("zod/mini");
+var import_node_path146 = require("path");
+var import_mini78 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
     const rulesyncMcp = await RulesyncMcp.fromFile({
       validate: true
     });
-    const relativePathFromCwd = (0, import_node_path143.join)(
+    const relativePathFromCwd = (0, import_node_path146.join)(
       rulesyncMcp.getRelativeDirPath(),
       rulesyncMcp.getRelativeFilePath()
     );
@@ -23013,7 +23778,7 @@ async function putMcpFile({ content }) {
     const paths = RulesyncMcp.getSettablePaths();
     const relativeDirPath = paths.recommended.relativeDirPath;
     const relativeFilePath = paths.recommended.relativeFilePath;
-    const fullPath = (0, import_node_path143.join)(baseDir, relativeDirPath, relativeFilePath);
+    const fullPath = (0, import_node_path146.join)(baseDir, relativeDirPath, relativeFilePath);
     const rulesyncMcp = new RulesyncMcp({
       baseDir,
       relativeDirPath,
@@ -23021,9 +23786,9 @@ async function putMcpFile({ content }) {
       fileContent: content,
       validate: true
     });
-    await ensureDir((0, import_node_path143.join)(baseDir, relativeDirPath));
+    await ensureDir((0, import_node_path146.join)(baseDir, relativeDirPath));
     await writeFileContent(fullPath, content);
-    const relativePathFromCwd = (0, import_node_path143.join)(relativeDirPath, relativeFilePath);
+    const relativePathFromCwd = (0, import_node_path146.join)(relativeDirPath, relativeFilePath);
     return {
       relativePathFromCwd,
       content: rulesyncMcp.getFileContent()
@@ -23041,15 +23806,15 @@ async function deleteMcpFile() {
   try {
     const baseDir = process.cwd();
     const paths = RulesyncMcp.getSettablePaths();
-    const recommendedPath = (0, import_node_path143.join)(
+    const recommendedPath = (0, import_node_path146.join)(
       baseDir,
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
-    const legacyPath = (0, import_node_path143.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
+    const legacyPath = (0, import_node_path146.join)(baseDir, paths.legacy.relativeDirPath, paths.legacy.relativeFilePath);
     await removeFile(recommendedPath);
     await removeFile(legacyPath);
-    const relativePathFromCwd = (0, import_node_path143.join)(
+    const relativePathFromCwd = (0, import_node_path146.join)(
       paths.recommended.relativeDirPath,
       paths.recommended.relativeFilePath
     );
@@ -23066,11 +23831,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini74.z.object({}),
-  putMcpFile: import_mini74.z.object({
-    content: import_mini74.z.string()
+  getMcpFile: import_mini78.z.object({}),
+  putMcpFile: import_mini78.z.object({
+    content: import_mini78.z.string()
   }),
-  deleteMcpFile: import_mini74.z.object({})
+  deleteMcpFile: import_mini78.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -23103,13 +23868,13 @@ var mcpTools = {
 };
 
 // src/mcp/rules.ts
-var import_node_path144 = require("path");
-var import_mini75 = require("zod/mini");
+var import_node_path147 = require("path");
+var import_mini79 = 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_path144.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+  const rulesDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(rulesDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23122,7 +23887,7 @@ async function listRules() {
           });
           const frontmatter = rule.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23144,14 +23909,14 @@ async function getRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
   try {
     const rule = await RulesyncRule.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -23170,7 +23935,7 @@ async function putRule({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxRuleSizeBytes) {
     throw new Error(
@@ -23180,7 +23945,7 @@ async function putRule({
   try {
     const existingRules = await listRules();
     const isUpdate = existingRules.some(
-      (rule2) => rule2.relativePathFromCwd === (0, import_node_path144.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      (rule2) => rule2.relativePathFromCwd === (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingRules.length >= maxRulesCount) {
       throw new Error(
@@ -23195,11 +23960,11 @@ async function putRule({
       body,
       validate: true
     });
-    const rulesDir = (0, import_node_path144.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
+    const rulesDir = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH);
     await ensureDir(rulesDir);
     await writeFileContent(rule.getFilePath(), rule.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename),
       frontmatter: rule.getFrontmatter(),
       body: rule.getBody()
     };
@@ -23214,12 +23979,12 @@ async function deleteRule({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path144.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path144.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path147.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path147.join)(process.cwd(), RULESYNC_RULES_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path144.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(`Failed to delete rule file ${relativePathFromCwd}: ${formatError(error)}`, {
@@ -23228,23 +23993,23 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini75.z.object({}),
-  getRule: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string()
+  listRules: import_mini79.z.object({}),
+  getRule: import_mini79.z.object({
+    relativePathFromCwd: import_mini79.z.string()
   }),
-  putRule: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string(),
+  putRule: import_mini79.z.object({
+    relativePathFromCwd: import_mini79.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini75.z.string()
+    body: import_mini79.z.string()
   }),
-  deleteRule: import_mini75.z.object({
-    relativePathFromCwd: import_mini75.z.string()
+  deleteRule: import_mini79.z.object({
+    relativePathFromCwd: import_mini79.z.string()
   })
 };
 var ruleTools = {
   listRules: {
     name: "listRules",
-    description: `List all rules from ${(0, import_node_path144.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all rules from ${(0, import_node_path147.join)(RULESYNC_RULES_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: ruleToolSchemas.listRules,
     execute: async () => {
       const rules = await listRules();
@@ -23286,8 +24051,8 @@ var ruleTools = {
 };
 
 // src/mcp/skills.ts
-var import_node_path145 = require("path");
-var import_mini76 = require("zod/mini");
+var import_node_path148 = require("path");
+var import_mini80 = require("zod/mini");
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -23304,19 +24069,19 @@ function mcpSkillFileToAiDirFile(file) {
   };
 }
 function extractDirName(relativeDirPathFromCwd) {
-  const dirName = (0, import_node_path145.basename)(relativeDirPathFromCwd);
+  const dirName = (0, import_node_path148.basename)(relativeDirPathFromCwd);
   if (!dirName) {
     throw new Error(`Invalid path: ${relativeDirPathFromCwd}`);
   }
   return dirName;
 }
 async function listSkills() {
-  const skillsDir = (0, import_node_path145.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
+  const skillsDir = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH);
   try {
-    const skillDirPaths = await findFilesByGlobs((0, import_node_path145.join)(skillsDir, "*"), { type: "dir" });
+    const skillDirPaths = await findFilesByGlobs((0, import_node_path148.join)(skillsDir, "*"), { type: "dir" });
     const skills = await Promise.all(
       skillDirPaths.map(async (dirPath) => {
-        const dirName = (0, import_node_path145.basename)(dirPath);
+        const dirName = (0, import_node_path148.basename)(dirPath);
         if (!dirName) return null;
         try {
           const skill = await RulesyncSkill.fromDir({
@@ -23324,7 +24089,7 @@ async function listSkills() {
           });
           const frontmatter = skill.getFrontmatter();
           return {
-            relativeDirPathFromCwd: (0, import_node_path145.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+            relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
             frontmatter
           };
         } catch (error) {
@@ -23352,7 +24117,7 @@ async function getSkill({ relativeDirPathFromCwd }) {
       dirName
     });
     return {
-      relativeDirPathFromCwd: (0, import_node_path145.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -23386,7 +24151,7 @@ async function putSkill({
   try {
     const existingSkills = await listSkills();
     const isUpdate = existingSkills.some(
-      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path145.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      (skill2) => skill2.relativeDirPathFromCwd === (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     );
     if (!isUpdate && existingSkills.length >= maxSkillsCount) {
       throw new Error(
@@ -23403,9 +24168,9 @@ async function putSkill({
       otherFiles: aiDirFiles,
       validate: true
     });
-    const skillDirPath = (0, import_node_path145.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+    const skillDirPath = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
     await ensureDir(skillDirPath);
-    const skillFilePath = (0, import_node_path145.join)(skillDirPath, SKILL_FILE_NAME);
+    const skillFilePath = (0, import_node_path148.join)(skillDirPath, SKILL_FILE_NAME);
     const skillFileContent = stringifyFrontmatter(body, frontmatter);
     await writeFileContent(skillFilePath, skillFileContent);
     for (const file of otherFiles) {
@@ -23413,15 +24178,15 @@ async function putSkill({
         relativePath: file.name,
         intendedRootDir: skillDirPath
       });
-      const filePath = (0, import_node_path145.join)(skillDirPath, file.name);
-      const fileDir = (0, import_node_path145.join)(skillDirPath, (0, import_node_path145.dirname)(file.name));
+      const filePath = (0, import_node_path148.join)(skillDirPath, file.name);
+      const fileDir = (0, import_node_path148.join)(skillDirPath, (0, import_node_path148.dirname)(file.name));
       if (fileDir !== skillDirPath) {
         await ensureDir(fileDir);
       }
       await writeFileContent(filePath, file.body);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path145.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
+      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName),
       frontmatter: skill.getFrontmatter(),
       body: skill.getBody(),
       otherFiles: skill.getOtherFiles().map(aiDirFileToMcpSkillFile)
@@ -23443,13 +24208,13 @@ async function deleteSkill({
     intendedRootDir: process.cwd()
   });
   const dirName = extractDirName(relativeDirPathFromCwd);
-  const skillDirPath = (0, import_node_path145.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
+  const skillDirPath = (0, import_node_path148.join)(process.cwd(), RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName);
   try {
     if (await directoryExists(skillDirPath)) {
       await removeDirectory(skillDirPath);
     }
     return {
-      relativeDirPathFromCwd: (0, import_node_path145.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
+      relativeDirPathFromCwd: (0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, dirName)
     };
   } catch (error) {
     throw new Error(
@@ -23460,29 +24225,29 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini76.z.object({
-  name: import_mini76.z.string(),
-  body: import_mini76.z.string()
+var McpSkillFileSchema = import_mini80.z.object({
+  name: import_mini80.z.string(),
+  body: import_mini80.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini76.z.object({}),
-  getSkill: import_mini76.z.object({
-    relativeDirPathFromCwd: import_mini76.z.string()
+  listSkills: import_mini80.z.object({}),
+  getSkill: import_mini80.z.object({
+    relativeDirPathFromCwd: import_mini80.z.string()
   }),
-  putSkill: import_mini76.z.object({
-    relativeDirPathFromCwd: import_mini76.z.string(),
+  putSkill: import_mini80.z.object({
+    relativeDirPathFromCwd: import_mini80.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini76.z.string(),
-    otherFiles: import_mini76.z.optional(import_mini76.z.array(McpSkillFileSchema))
+    body: import_mini80.z.string(),
+    otherFiles: import_mini80.z.optional(import_mini80.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini76.z.object({
-    relativeDirPathFromCwd: import_mini76.z.string()
+  deleteSkill: import_mini80.z.object({
+    relativeDirPathFromCwd: import_mini80.z.string()
   })
 };
 var skillTools = {
   listSkills: {
     name: "listSkills",
-    description: `List all skills from ${(0, import_node_path145.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
+    description: `List all skills from ${(0, import_node_path148.join)(RULESYNC_SKILLS_RELATIVE_DIR_PATH, "*", SKILL_FILE_NAME)} with their frontmatter.`,
     parameters: skillToolSchemas.listSkills,
     execute: async () => {
       const skills = await listSkills();
@@ -23525,13 +24290,13 @@ var skillTools = {
 };
 
 // src/mcp/subagents.ts
-var import_node_path146 = require("path");
-var import_mini77 = require("zod/mini");
+var import_node_path149 = require("path");
+var import_mini81 = 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_path146.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+  const subagentsDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
   try {
     const files = await listDirectoryFiles(subagentsDir);
     const mdFiles = files.filter((file) => file.endsWith(".md"));
@@ -23544,7 +24309,7 @@ async function listSubagents() {
           });
           const frontmatter = subagent.getFrontmatter();
           return {
-            relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
+            relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, file),
             frontmatter
           };
         } catch (error) {
@@ -23568,14 +24333,14 @@ async function getSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
   try {
     const subagent = await RulesyncSubagent.fromFile({
       relativeFilePath: filename,
       validate: true
     });
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -23594,7 +24359,7 @@ async function putSubagent({
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
   const estimatedSize = JSON.stringify(frontmatter).length + body.length;
   if (estimatedSize > maxSubagentSizeBytes) {
     throw new Error(
@@ -23604,7 +24369,7 @@ async function putSubagent({
   try {
     const existingSubagents = await listSubagents();
     const isUpdate = existingSubagents.some(
-      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path146.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      (subagent2) => subagent2.relativePathFromCwd === (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     );
     if (!isUpdate && existingSubagents.length >= maxSubagentsCount) {
       throw new Error(
@@ -23619,11 +24384,11 @@ async function putSubagent({
       body,
       validate: true
     });
-    const subagentsDir = (0, import_node_path146.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
+    const subagentsDir = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH);
     await ensureDir(subagentsDir);
     await writeFileContent(subagent.getFilePath(), subagent.getFileContent());
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename),
       frontmatter: subagent.getFrontmatter(),
       body: subagent.getBody()
     };
@@ -23638,12 +24403,12 @@ async function deleteSubagent({ relativePathFromCwd }) {
     relativePath: relativePathFromCwd,
     intendedRootDir: process.cwd()
   });
-  const filename = (0, import_node_path146.basename)(relativePathFromCwd);
-  const fullPath = (0, import_node_path146.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
+  const filename = (0, import_node_path149.basename)(relativePathFromCwd);
+  const fullPath = (0, import_node_path149.join)(process.cwd(), RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename);
   try {
     await removeFile(fullPath);
     return {
-      relativePathFromCwd: (0, import_node_path146.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
+      relativePathFromCwd: (0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, filename)
     };
   } catch (error) {
     throw new Error(
@@ -23655,23 +24420,23 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini77.z.object({}),
-  getSubagent: import_mini77.z.object({
-    relativePathFromCwd: import_mini77.z.string()
+  listSubagents: import_mini81.z.object({}),
+  getSubagent: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string()
   }),
-  putSubagent: import_mini77.z.object({
-    relativePathFromCwd: import_mini77.z.string(),
+  putSubagent: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini77.z.string()
+    body: import_mini81.z.string()
   }),
-  deleteSubagent: import_mini77.z.object({
-    relativePathFromCwd: import_mini77.z.string()
+  deleteSubagent: import_mini81.z.object({
+    relativePathFromCwd: import_mini81.z.string()
   })
 };
 var subagentTools = {
   listSubagents: {
     name: "listSubagents",
-    description: `List all subagents from ${(0, import_node_path146.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
+    description: `List all subagents from ${(0, import_node_path149.join)(RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH, "*.md")} with their frontmatter.`,
     parameters: subagentToolSchemas.listSubagents,
     execute: async () => {
       const subagents = await listSubagents();
@@ -23713,7 +24478,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini78.z.enum([
+var rulesyncFeatureSchema = import_mini82.z.enum([
   "rule",
   "command",
   "subagent",
@@ -23723,21 +24488,21 @@ var rulesyncFeatureSchema = import_mini78.z.enum([
   "generate",
   "import"
 ]);
-var rulesyncOperationSchema = import_mini78.z.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = import_mini78.z.object({
-  name: import_mini78.z.string(),
-  body: import_mini78.z.string()
+var rulesyncOperationSchema = import_mini82.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini82.z.object({
+  name: import_mini82.z.string(),
+  body: import_mini82.z.string()
 });
-var rulesyncToolSchema = import_mini78.z.object({
+var rulesyncToolSchema = import_mini82.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini78.z.optional(import_mini78.z.string()),
-  frontmatter: import_mini78.z.optional(import_mini78.z.unknown()),
-  body: import_mini78.z.optional(import_mini78.z.string()),
-  otherFiles: import_mini78.z.optional(import_mini78.z.array(skillFileSchema)),
-  content: import_mini78.z.optional(import_mini78.z.string()),
-  generateOptions: import_mini78.z.optional(generateOptionsSchema),
-  importOptions: import_mini78.z.optional(importOptionsSchema)
+  targetPathFromCwd: import_mini82.z.optional(import_mini82.z.string()),
+  frontmatter: import_mini82.z.optional(import_mini82.z.unknown()),
+  body: import_mini82.z.optional(import_mini82.z.string()),
+  otherFiles: import_mini82.z.optional(import_mini82.z.array(skillFileSchema)),
+  content: import_mini82.z.optional(import_mini82.z.string()),
+  generateOptions: import_mini82.z.optional(generateOptionsSchema),
+  importOptions: import_mini82.z.optional(importOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -24345,7 +25110,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "7.28.0";
+var getVersion = () => "7.30.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }