rulesync 8.17.0 → 8.18.0

package/dist/cli/index.cjs

@@ -8016,14 +8016,21 @@ var ClineMcp = class _ClineMcp extends ToolMcp {
 // src/features/mcp/codexcli-mcp.ts
 var import_node_path54 = require("path");
 var smolToml3 = __toESM(require("smol-toml"), 1);
+var MAX_REMOVE_EMPTY_ENTRIES_DEPTH = 32;
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isPlainObject2(value) {
+  if (!isRecord(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
 function convertFromCodexFormat(codexMcp) {
   const result = {};
   for (const [name, config] of Object.entries(codexMcp)) {
-    if (typeof config !== "object" || config === null || Array.isArray(config)) {
-      continue;
-    }
+    if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+    if (!isRecord(config)) continue;
     const converted = {};
     for (const [key, value] of Object.entries(config)) {
+      if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
       if (key === "enabled") {
         if (value === false) {
           converted["disabled"] = true;
@@ -8045,8 +8052,11 @@ function convertFromCodexFormat(codexMcp) {
 function convertToCodexFormat(mcpServers) {
   const result = {};
   for (const [name, config] of Object.entries(mcpServers)) {
+    if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+    if (!isRecord(config)) continue;
     const converted = {};
     for (const [key, value] of Object.entries(config)) {
+      if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
       if (key === "disabled") {
         if (value === true) {
           converted["enabled"] = false;
@@ -8128,6 +8138,14 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
     const mcpServers = rulesyncMcp.getJson().mcpServers;
     const converted = convertToCodexFormat(mcpServers);
     const filteredMcpServers = this.removeEmptyEntries(converted);
+    for (const name of Object.keys(converted)) {
+      if (!Object.hasOwn(filteredMcpServers, name)) {
+        warnWithFallback(
+          void 0,
+          `MCP server "${name}" had no non-empty configuration and was dropped from the codex CLI config`
+        );
+      }
+    }
     configToml["mcp_servers"] = filteredMcpServers;
     return new _CodexcliMcp({
       outputRoot,
@@ -8147,13 +8165,21 @@ var CodexcliMcp = class _CodexcliMcp extends ToolMcp {
   validate() {
     return { success: true, error: null };
   }
-  static removeEmptyEntries(obj) {
+  static removeEmptyEntries(obj, depth = 0) {
     if (!obj) return {};
+    if (depth > MAX_REMOVE_EMPTY_ENTRIES_DEPTH) {
+      warnWithFallback(
+        void 0,
+        `removeEmptyEntries: maximum recursion depth (${MAX_REMOVE_EMPTY_ENTRIES_DEPTH}) exceeded; empty nested objects may remain`
+      );
+      return obj;
+    }
     const filtered = {};
     for (const [key, value] of Object.entries(obj)) {
+      if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
       if (value === null) continue;
-      if (typeof value === "object" && !Array.isArray(value)) {
-        const cleaned = this.removeEmptyEntries(value);
+      if (isPlainObject2(value)) {
+        const cleaned = this.removeEmptyEntries(value, depth + 1);
         if (Object.keys(cleaned).length === 0) continue;
         filtered[key] = cleaned;
         continue;
@@ -9846,7 +9872,13 @@ var toolMcpFactories = /* @__PURE__ */ new Map([
       class: KiloMcp,
       meta: {
         supportsProject: true,
-        supportsGlobal: false,
+        // Kilo CLI reads global MCP from `~/.config/kilo/kilo.json` (or
+        // `kilo.jsonc`). The path machinery in `KiloMcp.getSettablePaths`
+        // already routes global mode to that location; only this flag
+        // was gating it off. Kilo is an OpenCode fork and uses an
+        // identical native MCP schema, so global parity with opencode
+        // is the natural state.
+        supportsGlobal: true,
         supportsEnabledTools: false,
         supportsDisabledTools: false
       }
@@ -12967,7 +12999,7 @@ var PermissionsProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path154 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini79 = require("zod/mini");
+var import_mini80 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -17919,7 +17951,7 @@ var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path125 = require("path");
-var import_mini72 = require("zod/mini");
+var import_mini73 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
 var import_node_path113 = require("path");
@@ -19079,6 +19111,7 @@ var JunieSubagent = class _JunieSubagent extends ToolSubagent {
 
 // src/features/subagents/kilo-subagent.ts
 var import_node_path121 = require("path");
+var import_mini71 = require("zod/mini");
 
 // src/features/subagents/opencode-style-subagent.ts
 var import_node_path120 = require("path");
@@ -19145,7 +19178,13 @@ var OpenCodeStyleSubagent = class extends ToolSubagent {
 };
 
 // src/features/subagents/kilo-subagent.ts
-var KiloSubagentFrontmatterSchema = OpenCodeStyleSubagentFrontmatterSchema;
+var KiloSubagentFrontmatterSchema = import_mini71.z.looseObject({
+  description: import_mini71.z.optional(import_mini71.z.string()),
+  // Kilo's documented default for user-defined agents is "all":
+  // available both as a top-level pick and as a subagent.
+  mode: import_mini71.z._default(import_mini71.z.string(), "all"),
+  name: import_mini71.z.optional(import_mini71.z.string())
+});
 var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
   getToolTarget() {
     return "kilo";
@@ -19165,12 +19204,11 @@ var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
   }) {
     const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
     const kiloSection = rulesyncFrontmatter.kilo ?? {};
-    const kiloFrontmatter = {
+    const kiloFrontmatter = KiloSubagentFrontmatterSchema.parse({
       ...kiloSection,
       description: rulesyncFrontmatter.description,
-      mode: typeof kiloSection.mode === "string" ? kiloSection.mode : "subagent",
       ...rulesyncFrontmatter.name && { name: rulesyncFrontmatter.name }
-    };
+    });
     const body = rulesyncSubagent.getBody();
     const fileContent = stringifyFrontmatter(body, kiloFrontmatter);
     const paths = this.getSettablePaths({ global });
@@ -19219,38 +19257,40 @@ var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
   static forDeletion({
     outputRoot = process.cwd(),
     relativeDirPath,
-    relativeFilePath
+    relativeFilePath,
+    global = false
   }) {
     return new _KiloSubagent({
       outputRoot,
       relativeDirPath,
       relativeFilePath,
-      frontmatter: { description: "", mode: "subagent" },
+      frontmatter: { description: "", mode: "all" },
       body: "",
       fileContent: "",
-      validate: false
+      validate: false,
+      global
     });
   }
 };
 
 // src/features/subagents/kiro-subagent.ts
 var import_node_path122 = require("path");
-var import_mini71 = require("zod/mini");
-var KiroCliSubagentJsonSchema = import_mini71.z.looseObject({
-  name: import_mini71.z.string(),
-  description: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.string())),
-  prompt: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.string())),
-  tools: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.array(import_mini71.z.string()))),
-  toolAliases: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.record(import_mini71.z.string(), import_mini71.z.string()))),
-  toolSettings: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.unknown())),
-  toolSchema: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.unknown())),
-  hooks: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.record(import_mini71.z.string(), import_mini71.z.array(import_mini71.z.unknown())))),
-  model: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.string())),
-  mcpServers: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.record(import_mini71.z.string(), import_mini71.z.unknown()))),
-  useLegacyMcpJson: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.boolean())),
-  resources: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.array(import_mini71.z.string()))),
-  allowedTools: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.array(import_mini71.z.string()))),
-  includeMcpJson: import_mini71.z.optional(import_mini71.z.nullable(import_mini71.z.boolean()))
+var import_mini72 = require("zod/mini");
+var KiroCliSubagentJsonSchema = import_mini72.z.looseObject({
+  name: import_mini72.z.string(),
+  description: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.string())),
+  prompt: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.string())),
+  tools: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.array(import_mini72.z.string()))),
+  toolAliases: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.string()))),
+  toolSettings: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.unknown())),
+  toolSchema: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.unknown())),
+  hooks: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.array(import_mini72.z.unknown())))),
+  model: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.string())),
+  mcpServers: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.record(import_mini72.z.string(), import_mini72.z.unknown()))),
+  useLegacyMcpJson: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.boolean())),
+  resources: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.array(import_mini72.z.string()))),
+  allowedTools: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.array(import_mini72.z.string()))),
+  includeMcpJson: import_mini72.z.optional(import_mini72.z.nullable(import_mini72.z.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -19616,7 +19656,7 @@ var subagentsProcessorToolTargetTuple = [
   "rovodev",
   "takt"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini72.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini73.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -19945,48 +19985,48 @@ var import_node_path127 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path126 = require("path");
-var import_mini73 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini73.z.object({
-  root: import_mini73.z.optional(import_mini73.z.boolean()),
-  localRoot: import_mini73.z.optional(import_mini73.z.boolean()),
-  targets: import_mini73.z._default(RulesyncTargetsSchema, ["*"]),
-  description: import_mini73.z.optional(import_mini73.z.string()),
-  globs: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string())),
-  agentsmd: import_mini73.z.optional(
-    import_mini73.z.looseObject({
+var import_mini74 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini74.z.object({
+  root: import_mini74.z.optional(import_mini74.z.boolean()),
+  localRoot: import_mini74.z.optional(import_mini74.z.boolean()),
+  targets: import_mini74.z._default(RulesyncTargetsSchema, ["*"]),
+  description: import_mini74.z.optional(import_mini74.z.string()),
+  globs: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string())),
+  agentsmd: import_mini74.z.optional(
+    import_mini74.z.looseObject({
       // @example "path/to/subproject"
-      subprojectPath: import_mini73.z.optional(import_mini73.z.string())
+      subprojectPath: import_mini74.z.optional(import_mini74.z.string())
     })
   ),
-  claudecode: import_mini73.z.optional(
-    import_mini73.z.looseObject({
+  claudecode: import_mini74.z.optional(
+    import_mini74.z.looseObject({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example ["src/**/*.ts", "tests/**/*.test.ts"]
-      paths: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string()))
+      paths: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string()))
     })
   ),
-  cursor: import_mini73.z.optional(
-    import_mini73.z.looseObject({
-      alwaysApply: import_mini73.z.optional(import_mini73.z.boolean()),
-      description: import_mini73.z.optional(import_mini73.z.string()),
-      globs: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string()))
+  cursor: import_mini74.z.optional(
+    import_mini74.z.looseObject({
+      alwaysApply: import_mini74.z.optional(import_mini74.z.boolean()),
+      description: import_mini74.z.optional(import_mini74.z.string()),
+      globs: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string()))
     })
   ),
-  copilot: import_mini73.z.optional(
-    import_mini73.z.looseObject({
-      excludeAgent: import_mini73.z.optional(import_mini73.z.union([import_mini73.z.literal("code-review"), import_mini73.z.literal("coding-agent")]))
+  copilot: import_mini74.z.optional(
+    import_mini74.z.looseObject({
+      excludeAgent: import_mini74.z.optional(import_mini74.z.union([import_mini74.z.literal("code-review"), import_mini74.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini73.z.optional(
-    import_mini73.z.looseObject({
-      trigger: import_mini73.z.optional(import_mini73.z.string()),
-      globs: import_mini73.z.optional(import_mini73.z.array(import_mini73.z.string()))
+  antigravity: import_mini74.z.optional(
+    import_mini74.z.looseObject({
+      trigger: import_mini74.z.optional(import_mini74.z.string()),
+      globs: import_mini74.z.optional(import_mini74.z.array(import_mini74.z.string()))
     })
   ),
-  takt: import_mini73.z.optional(
-    import_mini73.z.looseObject({
+  takt: import_mini74.z.optional(
+    import_mini74.z.looseObject({
       // Rename the emitted file stem (e.g. "coder.md" → "{name}.md").
-      name: import_mini73.z.optional(import_mini73.z.string())
+      name: import_mini74.z.optional(import_mini74.z.string())
     })
   )
 });
@@ -20287,20 +20327,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path129 = require("path");
-var import_mini74 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini74.z.looseObject({
-  trigger: import_mini74.z.optional(
-    import_mini74.z.union([
-      import_mini74.z.literal("always_on"),
-      import_mini74.z.literal("glob"),
-      import_mini74.z.literal("manual"),
-      import_mini74.z.literal("model_decision"),
-      import_mini74.z.string()
+var import_mini75 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini75.z.looseObject({
+  trigger: import_mini75.z.optional(
+    import_mini75.z.union([
+      import_mini75.z.literal("always_on"),
+      import_mini75.z.literal("glob"),
+      import_mini75.z.literal("manual"),
+      import_mini75.z.literal("model_decision"),
+      import_mini75.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini74.z.optional(import_mini74.z.string()),
-  description: import_mini74.z.optional(import_mini74.z.string())
+  globs: import_mini75.z.optional(import_mini75.z.string()),
+  description: import_mini75.z.optional(import_mini75.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -20887,9 +20927,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path133 = require("path");
-var import_mini75 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini75.z.object({
-  paths: import_mini75.z.optional(import_mini75.z.array(import_mini75.z.string()))
+var import_mini76 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini76.z.object({
+  paths: import_mini76.z.optional(import_mini76.z.array(import_mini76.z.string()))
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -21105,9 +21145,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path134 = require("path");
-var import_mini76 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini76.z.object({
-  description: import_mini76.z.string()
+var import_mini77 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini77.z.object({
+  description: import_mini77.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths(_options = {}) {
@@ -21286,11 +21326,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path136 = require("path");
-var import_mini77 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini77.z.object({
-  description: import_mini77.z.optional(import_mini77.z.string()),
-  applyTo: import_mini77.z.optional(import_mini77.z.string()),
-  excludeAgent: import_mini77.z.optional(import_mini77.z.union([import_mini77.z.literal("code-review"), import_mini77.z.literal("coding-agent")]))
+var import_mini78 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini78.z.object({
+  description: import_mini78.z.optional(import_mini78.z.string()),
+  applyTo: import_mini78.z.optional(import_mini78.z.string()),
+  excludeAgent: import_mini78.z.optional(import_mini78.z.union([import_mini78.z.literal("code-review"), import_mini78.z.literal("coding-agent")]))
 });
 var normalizeRelativePath = (path5) => path5.replace(/\\/g, "/").replace(/\/+/g, "/");
 var sameRelativePath = (leftDir, leftFile, rightDir, rightFile) => normalizeRelativePath((0, import_node_path136.join)(leftDir, leftFile)) === normalizeRelativePath((0, import_node_path136.join)(rightDir, rightFile));
@@ -21544,11 +21584,11 @@ var CopilotcliRule = class _CopilotcliRule extends CopilotRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path137 = require("path");
-var import_mini78 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini78.z.object({
-  description: import_mini78.z.optional(import_mini78.z.string()),
-  globs: import_mini78.z.optional(import_mini78.z.string()),
-  alwaysApply: import_mini78.z.optional(import_mini78.z.boolean())
+var import_mini79 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini79.z.object({
+  description: import_mini79.z.optional(import_mini79.z.string()),
+  globs: import_mini79.z.optional(import_mini79.z.string()),
+  alwaysApply: import_mini79.z.optional(import_mini79.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -23431,11 +23471,11 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini79.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini80.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path154.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
-var RulesFeatureOptionsSchema = import_mini79.z.looseObject({
-  ruleDiscoveryMode: import_mini79.z.optional(import_mini79.z.enum(["none", "explicit"])),
-  includeLocalRoot: import_mini79.z.optional(import_mini79.z.boolean())
+var RulesFeatureOptionsSchema = import_mini80.z.looseObject({
+  ruleDiscoveryMode: import_mini80.z.optional(import_mini80.z.enum(["none", "explicit"])),
+  includeLocalRoot: import_mini80.z.optional(import_mini80.z.boolean())
 });
 var resolveRuleDiscoveryMode = ({
   defaultMode,
@@ -23456,8 +23496,8 @@ var resolveRuleDiscoveryMode = ({
   }
   return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
 };
-var IncludeLocalRootSchema = import_mini79.z.looseObject({
-  includeLocalRoot: import_mini79.z.optional(import_mini79.z.boolean())
+var IncludeLocalRootSchema = import_mini80.z.looseObject({
+  includeLocalRoot: import_mini80.z.optional(import_mini80.z.boolean())
 });
 var resolveIncludeLocalRoot = (options) => {
   if (!options) return true;
@@ -24736,51 +24776,51 @@ var import_request_error = require("@octokit/request-error");
 var import_rest = require("@octokit/rest");
 
 // src/types/fetch.ts
-var import_mini81 = require("zod/mini");
+var import_mini82 = require("zod/mini");
 
 // src/types/fetch-targets.ts
-var import_mini80 = require("zod/mini");
+var import_mini81 = require("zod/mini");
 var ALL_FETCH_TARGETS = ["rulesync", ...ALL_TOOL_TARGETS];
-var FetchTargetSchema = import_mini80.z.enum(ALL_FETCH_TARGETS);
+var FetchTargetSchema = import_mini81.z.enum(ALL_FETCH_TARGETS);
 
 // src/types/fetch.ts
-var ConflictStrategySchema = import_mini81.z.enum(["skip", "overwrite"]);
-var GitHubFileTypeSchema = import_mini81.z.enum(["file", "dir", "symlink", "submodule"]);
-var GitHubFileEntrySchema = import_mini81.z.looseObject({
-  name: import_mini81.z.string(),
-  path: import_mini81.z.string(),
-  sha: import_mini81.z.string(),
-  size: import_mini81.z.number(),
+var ConflictStrategySchema = import_mini82.z.enum(["skip", "overwrite"]);
+var GitHubFileTypeSchema = import_mini82.z.enum(["file", "dir", "symlink", "submodule"]);
+var GitHubFileEntrySchema = import_mini82.z.looseObject({
+  name: import_mini82.z.string(),
+  path: import_mini82.z.string(),
+  sha: import_mini82.z.string(),
+  size: import_mini82.z.number(),
   type: GitHubFileTypeSchema,
-  download_url: import_mini81.z.nullable(import_mini81.z.string())
+  download_url: import_mini82.z.nullable(import_mini82.z.string())
 });
-var FetchOptionsSchema = import_mini81.z.looseObject({
-  target: import_mini81.z.optional(FetchTargetSchema),
-  features: import_mini81.z.optional(import_mini81.z.array(import_mini81.z.enum(ALL_FEATURES_WITH_WILDCARD))),
-  ref: import_mini81.z.optional(import_mini81.z.string()),
-  path: import_mini81.z.optional(import_mini81.z.string()),
-  output: import_mini81.z.optional(import_mini81.z.string()),
-  conflict: import_mini81.z.optional(ConflictStrategySchema),
-  token: import_mini81.z.optional(import_mini81.z.string()),
-  verbose: import_mini81.z.optional(import_mini81.z.boolean()),
-  silent: import_mini81.z.optional(import_mini81.z.boolean())
+var FetchOptionsSchema = import_mini82.z.looseObject({
+  target: import_mini82.z.optional(FetchTargetSchema),
+  features: import_mini82.z.optional(import_mini82.z.array(import_mini82.z.enum(ALL_FEATURES_WITH_WILDCARD))),
+  ref: import_mini82.z.optional(import_mini82.z.string()),
+  path: import_mini82.z.optional(import_mini82.z.string()),
+  output: import_mini82.z.optional(import_mini82.z.string()),
+  conflict: import_mini82.z.optional(ConflictStrategySchema),
+  token: import_mini82.z.optional(import_mini82.z.string()),
+  verbose: import_mini82.z.optional(import_mini82.z.boolean()),
+  silent: import_mini82.z.optional(import_mini82.z.boolean())
 });
-var FetchFileStatusSchema = import_mini81.z.enum(["created", "overwritten", "skipped"]);
-var GitHubRepoInfoSchema = import_mini81.z.looseObject({
-  default_branch: import_mini81.z.string(),
-  private: import_mini81.z.boolean()
+var FetchFileStatusSchema = import_mini82.z.enum(["created", "overwritten", "skipped"]);
+var GitHubRepoInfoSchema = import_mini82.z.looseObject({
+  default_branch: import_mini82.z.string(),
+  private: import_mini82.z.boolean()
 });
-var GitHubReleaseAssetSchema = import_mini81.z.looseObject({
-  name: import_mini81.z.string(),
-  browser_download_url: import_mini81.z.string(),
-  size: import_mini81.z.number()
+var GitHubReleaseAssetSchema = import_mini82.z.looseObject({
+  name: import_mini82.z.string(),
+  browser_download_url: import_mini82.z.string(),
+  size: import_mini82.z.number()
 });
-var GitHubReleaseSchema = import_mini81.z.looseObject({
-  tag_name: import_mini81.z.string(),
-  name: import_mini81.z.nullable(import_mini81.z.string()),
-  prerelease: import_mini81.z.boolean(),
-  draft: import_mini81.z.boolean(),
-  assets: import_mini81.z.array(GitHubReleaseAssetSchema)
+var GitHubReleaseSchema = import_mini82.z.looseObject({
+  tag_name: import_mini82.z.string(),
+  name: import_mini82.z.nullable(import_mini82.z.string()),
+  prerelease: import_mini82.z.boolean(),
+  draft: import_mini82.z.boolean(),
+  assets: import_mini82.z.array(GitHubReleaseAssetSchema)
 });
 
 // src/lib/github-client.ts
@@ -25081,9 +25121,9 @@ async function listDirectoryRecursive(params) {
 }
 
 // src/types/git-provider.ts
-var import_mini82 = require("zod/mini");
+var import_mini83 = require("zod/mini");
 var ALL_GIT_PROVIDERS = ["github", "gitlab"];
-var GitProviderSchema = import_mini82.z.enum(ALL_GIT_PROVIDERS);
+var GitProviderSchema = import_mini83.z.enum(ALL_GIT_PROVIDERS);
 
 // src/lib/source-parser.ts
 var GITHUB_HOSTS = /* @__PURE__ */ new Set(["github.com", "www.github.com"]);
@@ -27366,40 +27406,40 @@ var import_promise2 = require("es-toolkit/promise");
 // src/lib/apm/apm-lock.ts
 var import_node_path159 = require("path");
 var import_js_yaml3 = require("js-yaml");
-var import_mini83 = require("zod/mini");
+var import_mini84 = require("zod/mini");
 var APM_LOCKFILE_FILE_NAME = "rulesync-apm.lock.yaml";
 var APM_LOCKFILE_VERSION = "1";
 var RULESYNC_CONTENT_HASH_REGEX = /^sha256:[0-9a-f]{64}$/;
-var ApmLockDependencySchema = import_mini83.z.looseObject({
-  repo_url: import_mini83.z.string(),
-  resolved_commit: (0, import_mini83.optional)(
-    import_mini83.z.string().check((0, import_mini83.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolved_commit must be a 40-char hex SHA"))
+var ApmLockDependencySchema = import_mini84.z.looseObject({
+  repo_url: import_mini84.z.string(),
+  resolved_commit: (0, import_mini84.optional)(
+    import_mini84.z.string().check((0, import_mini84.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolved_commit must be a 40-char hex SHA"))
   ),
-  resolved_ref: (0, import_mini83.optional)(import_mini83.z.string()),
-  version: (0, import_mini83.optional)(import_mini83.z.string()),
-  depth: import_mini83.z.int().check((0, import_mini83.nonnegative)()),
-  resolved_by: (0, import_mini83.optional)(import_mini83.z.string()),
-  package_type: import_mini83.z.string(),
+  resolved_ref: (0, import_mini84.optional)(import_mini84.z.string()),
+  version: (0, import_mini84.optional)(import_mini84.z.string()),
+  depth: import_mini84.z.int().check((0, import_mini84.nonnegative)()),
+  resolved_by: (0, import_mini84.optional)(import_mini84.z.string()),
+  package_type: import_mini84.z.string(),
   // Intentionally loose: the upstream `apm` CLI may write content_hash values
   // that do not match the strict rulesync format. We accept any string on read
   // so that a lockfile produced by `apm` round-trips through rulesync without
   // throwing. Rulesync itself always writes values matching
   // `RULESYNC_CONTENT_HASH_REGEX`, and `--frozen` integrity checks only
   // enforce the comparison when the recorded hash matches that shape.
-  content_hash: (0, import_mini83.optional)(import_mini83.z.string()),
-  is_dev: (0, import_mini83.optional)(import_mini83.z.boolean()),
-  deployed_files: import_mini83.z.array(import_mini83.z.string()),
-  source: (0, import_mini83.optional)(import_mini83.z.string()),
-  local_path: (0, import_mini83.optional)(import_mini83.z.string()),
-  virtual_path: (0, import_mini83.optional)(import_mini83.z.string()),
-  is_virtual: (0, import_mini83.optional)(import_mini83.z.boolean())
+  content_hash: (0, import_mini84.optional)(import_mini84.z.string()),
+  is_dev: (0, import_mini84.optional)(import_mini84.z.boolean()),
+  deployed_files: import_mini84.z.array(import_mini84.z.string()),
+  source: (0, import_mini84.optional)(import_mini84.z.string()),
+  local_path: (0, import_mini84.optional)(import_mini84.z.string()),
+  virtual_path: (0, import_mini84.optional)(import_mini84.z.string()),
+  is_virtual: (0, import_mini84.optional)(import_mini84.z.boolean())
 });
-var ApmLockSchema = import_mini83.z.looseObject({
-  lockfile_version: import_mini83.z.literal("1"),
-  generated_at: import_mini83.z.string(),
-  apm_version: import_mini83.z.string(),
-  dependencies: import_mini83.z.array(ApmLockDependencySchema),
-  mcp_servers: (0, import_mini83.optional)(import_mini83.z.array(import_mini83.z.string()))
+var ApmLockSchema = import_mini84.z.looseObject({
+  lockfile_version: import_mini84.z.literal("1"),
+  generated_at: import_mini84.z.string(),
+  apm_version: import_mini84.z.string(),
+  dependencies: import_mini84.z.array(ApmLockDependencySchema),
+  mcp_servers: (0, import_mini84.optional)(import_mini84.z.array(import_mini84.z.string()))
 });
 function getApmLockPath(projectRoot) {
   return (0, import_node_path159.join)(projectRoot, APM_LOCKFILE_FILE_NAME);
@@ -27459,22 +27499,22 @@ function findApmLockDependency(lock, repoUrl) {
 // src/lib/apm/apm-manifest.ts
 var import_node_path160 = require("path");
 var import_js_yaml4 = require("js-yaml");
-var import_mini84 = require("zod/mini");
+var import_mini85 = require("zod/mini");
 var APM_MANIFEST_FILE_NAME = "apm.yml";
-var ApmObjectDependencySchema = import_mini84.z.looseObject({
-  git: (0, import_mini84.optional)(import_mini84.z.string()),
-  source: (0, import_mini84.optional)(import_mini84.z.string()),
-  path: (0, import_mini84.optional)(import_mini84.z.string()),
-  ref: (0, import_mini84.optional)(import_mini84.z.string()),
-  alias: (0, import_mini84.optional)(import_mini84.z.string())
+var ApmObjectDependencySchema = import_mini85.z.looseObject({
+  git: (0, import_mini85.optional)(import_mini85.z.string()),
+  source: (0, import_mini85.optional)(import_mini85.z.string()),
+  path: (0, import_mini85.optional)(import_mini85.z.string()),
+  ref: (0, import_mini85.optional)(import_mini85.z.string()),
+  alias: (0, import_mini85.optional)(import_mini85.z.string())
 });
-var ApmDependencyInputSchema = import_mini84.z.union([import_mini84.z.string(), ApmObjectDependencySchema]);
-var ApmManifestSchema = import_mini84.z.looseObject({
-  name: (0, import_mini84.optional)(import_mini84.z.string()),
-  version: (0, import_mini84.optional)(import_mini84.z.string()),
-  dependencies: (0, import_mini84.optional)(
-    import_mini84.z.looseObject({
-      apm: (0, import_mini84.optional)(import_mini84.z.array(ApmDependencyInputSchema))
+var ApmDependencyInputSchema = import_mini85.z.union([import_mini85.z.string(), ApmObjectDependencySchema]);
+var ApmManifestSchema = import_mini85.z.looseObject({
+  name: (0, import_mini85.optional)(import_mini85.z.string()),
+  version: (0, import_mini85.optional)(import_mini85.z.string()),
+  dependencies: (0, import_mini85.optional)(
+    import_mini85.z.looseObject({
+      apm: (0, import_mini85.optional)(import_mini85.z.array(ApmDependencyInputSchema))
     })
   )
 });
@@ -27996,29 +28036,29 @@ ${rest}`;
 // src/lib/gh/gh-lock.ts
 var import_node_path162 = require("path");
 var import_js_yaml6 = require("js-yaml");
-var import_mini85 = require("zod/mini");
+var import_mini86 = require("zod/mini");
 var GH_LOCKFILE_FILE_NAME = "rulesync-gh.lock.yaml";
 var GH_LOCKFILE_VERSION = "1";
 var RULESYNC_CONTENT_HASH_REGEX2 = /^sha256:[0-9a-f]{64}$/;
-var ScopeSchema = import_mini85.z.enum(["project", "user"]);
-var GhLockInstallationSchema = import_mini85.z.looseObject({
-  source: import_mini85.z.string(),
-  owner: import_mini85.z.string(),
-  repo: import_mini85.z.string(),
-  agent: import_mini85.z.string(),
+var ScopeSchema = import_mini86.z.enum(["project", "user"]);
+var GhLockInstallationSchema = import_mini86.z.looseObject({
+  source: import_mini86.z.string(),
+  owner: import_mini86.z.string(),
+  repo: import_mini86.z.string(),
+  agent: import_mini86.z.string(),
   scope: ScopeSchema,
-  skill: import_mini85.z.string(),
-  requested_ref: (0, import_mini85.optional)(import_mini85.z.string()),
-  resolved_ref: import_mini85.z.string(),
-  resolved_commit: import_mini85.z.string().check((0, import_mini85.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolved_commit must be a 40-char hex SHA")),
-  install_dir: import_mini85.z.string(),
-  deployed_files: import_mini85.z.array(import_mini85.z.string()),
-  content_hash: (0, import_mini85.optional)(import_mini85.z.string())
+  skill: import_mini86.z.string(),
+  requested_ref: (0, import_mini86.optional)(import_mini86.z.string()),
+  resolved_ref: import_mini86.z.string(),
+  resolved_commit: import_mini86.z.string().check((0, import_mini86.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolved_commit must be a 40-char hex SHA")),
+  install_dir: import_mini86.z.string(),
+  deployed_files: import_mini86.z.array(import_mini86.z.string()),
+  content_hash: (0, import_mini86.optional)(import_mini86.z.string())
 });
-var GhLockSchema = import_mini85.z.looseObject({
-  lockfile_version: import_mini85.z.literal("1"),
-  generated_at: import_mini85.z.string(),
-  installations: import_mini85.z.array(GhLockInstallationSchema)
+var GhLockSchema = import_mini86.z.looseObject({
+  lockfile_version: import_mini86.z.literal("1"),
+  generated_at: import_mini86.z.string(),
+  installations: import_mini86.z.array(GhLockInstallationSchema)
 });
 function getGhLockPath(projectRoot) {
   return (0, import_node_path162.join)(projectRoot, GH_LOCKFILE_FILE_NAME);
@@ -28703,27 +28743,27 @@ async function walkDirectory(dir, outputRoot, depth = 0, ctx = { totalFiles: 0,
 // src/lib/sources-lock.ts
 var import_node_crypto3 = require("crypto");
 var import_node_path166 = require("path");
-var import_mini86 = require("zod/mini");
+var import_mini87 = require("zod/mini");
 var LOCKFILE_VERSION = 1;
-var LockedSkillSchema = import_mini86.z.object({
-  integrity: import_mini86.z.string()
+var LockedSkillSchema = import_mini87.z.object({
+  integrity: import_mini87.z.string()
 });
-var LockedSourceSchema = import_mini86.z.object({
-  requestedRef: (0, import_mini86.optional)(import_mini86.z.string()),
-  resolvedRef: import_mini86.z.string().check((0, import_mini86.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
-  resolvedAt: (0, import_mini86.optional)(import_mini86.z.string()),
-  skills: import_mini86.z.record(import_mini86.z.string(), LockedSkillSchema)
+var LockedSourceSchema = import_mini87.z.object({
+  requestedRef: (0, import_mini87.optional)(import_mini87.z.string()),
+  resolvedRef: import_mini87.z.string().check((0, import_mini87.refine)((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
+  resolvedAt: (0, import_mini87.optional)(import_mini87.z.string()),
+  skills: import_mini87.z.record(import_mini87.z.string(), LockedSkillSchema)
 });
-var SourcesLockSchema = import_mini86.z.object({
-  lockfileVersion: import_mini86.z.number(),
-  sources: import_mini86.z.record(import_mini86.z.string(), LockedSourceSchema)
+var SourcesLockSchema = import_mini87.z.object({
+  lockfileVersion: import_mini87.z.number(),
+  sources: import_mini87.z.record(import_mini87.z.string(), LockedSourceSchema)
 });
-var LegacyLockedSourceSchema = import_mini86.z.object({
-  resolvedRef: import_mini86.z.string(),
-  skills: import_mini86.z.array(import_mini86.z.string())
+var LegacyLockedSourceSchema = import_mini87.z.object({
+  resolvedRef: import_mini87.z.string(),
+  skills: import_mini87.z.array(import_mini87.z.string())
 });
-var LegacySourcesLockSchema = import_mini86.z.object({
-  sources: import_mini86.z.record(import_mini86.z.string(), LegacyLockedSourceSchema)
+var LegacySourcesLockSchema = import_mini87.z.object({
+  sources: import_mini87.z.record(import_mini87.z.string(), LegacyLockedSourceSchema)
 });
 function migrateLegacyLock(params) {
   const { legacy, logger: logger5 } = params;
@@ -29496,11 +29536,11 @@ async function runGhInstall(logger5, options) {
 var import_fastmcp = require("fastmcp");
 
 // src/mcp/tools.ts
-var import_mini98 = require("zod/mini");
+var import_mini99 = require("zod/mini");
 
 // src/mcp/commands.ts
 var import_node_path168 = require("path");
-var import_mini87 = require("zod/mini");
+var import_mini88 = require("zod/mini");
 var logger = new ConsoleLogger({ verbose: false, silent: true });
 var maxCommandSizeBytes = 1024 * 1024;
 var maxCommandsCount = 1e3;
@@ -29628,17 +29668,17 @@ async function deleteCommand({ relativePathFromCwd }) {
   }
 }
 var commandToolSchemas = {
-  listCommands: import_mini87.z.object({}),
-  getCommand: import_mini87.z.object({
-    relativePathFromCwd: import_mini87.z.string()
+  listCommands: import_mini88.z.object({}),
+  getCommand: import_mini88.z.object({
+    relativePathFromCwd: import_mini88.z.string()
   }),
-  putCommand: import_mini87.z.object({
-    relativePathFromCwd: import_mini87.z.string(),
+  putCommand: import_mini88.z.object({
+    relativePathFromCwd: import_mini88.z.string(),
     frontmatter: RulesyncCommandFrontmatterSchema,
-    body: import_mini87.z.string()
+    body: import_mini88.z.string()
   }),
-  deleteCommand: import_mini87.z.object({
-    relativePathFromCwd: import_mini87.z.string()
+  deleteCommand: import_mini88.z.object({
+    relativePathFromCwd: import_mini88.z.string()
   })
 };
 var commandTools = {
@@ -29686,13 +29726,13 @@ var commandTools = {
 };
 
 // src/mcp/convert.ts
-var import_mini88 = require("zod/mini");
-var convertOptionsSchema = import_mini88.z.object({
-  from: import_mini88.z.string(),
-  to: import_mini88.z.array(import_mini88.z.string()),
-  features: import_mini88.z.optional(import_mini88.z.array(import_mini88.z.string())),
-  global: import_mini88.z.optional(import_mini88.z.boolean()),
-  dryRun: import_mini88.z.optional(import_mini88.z.boolean())
+var import_mini89 = require("zod/mini");
+var convertOptionsSchema = import_mini89.z.object({
+  from: import_mini89.z.string(),
+  to: import_mini89.z.array(import_mini89.z.string()),
+  features: import_mini89.z.optional(import_mini89.z.array(import_mini89.z.string())),
+  global: import_mini89.z.optional(import_mini89.z.boolean()),
+  dryRun: import_mini89.z.optional(import_mini89.z.boolean())
 });
 function parseToolTarget2(value, label) {
   const result = ToolTargetSchema.safeParse(value);
@@ -29788,15 +29828,15 @@ var convertTools = {
 };
 
 // src/mcp/generate.ts
-var import_mini89 = require("zod/mini");
-var generateOptionsSchema = import_mini89.z.object({
-  targets: import_mini89.z.optional(import_mini89.z.array(import_mini89.z.string())),
-  features: import_mini89.z.optional(import_mini89.z.array(import_mini89.z.string())),
-  delete: import_mini89.z.optional(import_mini89.z.boolean()),
-  global: import_mini89.z.optional(import_mini89.z.boolean()),
-  simulateCommands: import_mini89.z.optional(import_mini89.z.boolean()),
-  simulateSubagents: import_mini89.z.optional(import_mini89.z.boolean()),
-  simulateSkills: import_mini89.z.optional(import_mini89.z.boolean())
+var import_mini90 = require("zod/mini");
+var generateOptionsSchema = import_mini90.z.object({
+  targets: import_mini90.z.optional(import_mini90.z.array(import_mini90.z.string())),
+  features: import_mini90.z.optional(import_mini90.z.array(import_mini90.z.string())),
+  delete: import_mini90.z.optional(import_mini90.z.boolean()),
+  global: import_mini90.z.optional(import_mini90.z.boolean()),
+  simulateCommands: import_mini90.z.optional(import_mini90.z.boolean()),
+  simulateSubagents: import_mini90.z.optional(import_mini90.z.boolean()),
+  simulateSkills: import_mini90.z.optional(import_mini90.z.boolean())
 });
 async function executeGenerate(options = {}) {
   try {
@@ -29876,7 +29916,7 @@ var generateTools = {
 
 // src/mcp/hooks.ts
 var import_node_path169 = require("path");
-var import_mini90 = require("zod/mini");
+var import_mini91 = require("zod/mini");
 var maxHooksSizeBytes = 1024 * 1024;
 async function getHooksFile() {
   try {
@@ -29965,11 +30005,11 @@ async function deleteHooksFile() {
   }
 }
 var hooksToolSchemas = {
-  getHooksFile: import_mini90.z.object({}),
-  putHooksFile: import_mini90.z.object({
-    content: import_mini90.z.string()
+  getHooksFile: import_mini91.z.object({}),
+  putHooksFile: import_mini91.z.object({
+    content: import_mini91.z.string()
   }),
-  deleteHooksFile: import_mini90.z.object({})
+  deleteHooksFile: import_mini91.z.object({})
 };
 var hooksTools = {
   getHooksFile: {
@@ -30003,7 +30043,7 @@ var hooksTools = {
 
 // src/mcp/ignore.ts
 var import_node_path170 = require("path");
-var import_mini91 = require("zod/mini");
+var import_mini92 = require("zod/mini");
 var maxIgnoreFileSizeBytes = 100 * 1024;
 async function getIgnoreFile() {
   const ignoreFilePath = (0, import_node_path170.join)(process.cwd(), RULESYNC_AIIGNORE_RELATIVE_FILE_PATH);
@@ -30066,11 +30106,11 @@ async function deleteIgnoreFile() {
   }
 }
 var ignoreToolSchemas = {
-  getIgnoreFile: import_mini91.z.object({}),
-  putIgnoreFile: import_mini91.z.object({
-    content: import_mini91.z.string()
+  getIgnoreFile: import_mini92.z.object({}),
+  putIgnoreFile: import_mini92.z.object({
+    content: import_mini92.z.string()
   }),
-  deleteIgnoreFile: import_mini91.z.object({})
+  deleteIgnoreFile: import_mini92.z.object({})
 };
 var ignoreTools = {
   getIgnoreFile: {
@@ -30103,11 +30143,11 @@ var ignoreTools = {
 };
 
 // src/mcp/import.ts
-var import_mini92 = require("zod/mini");
-var importOptionsSchema = import_mini92.z.object({
-  target: import_mini92.z.string(),
-  features: import_mini92.z.optional(import_mini92.z.array(import_mini92.z.string())),
-  global: import_mini92.z.optional(import_mini92.z.boolean())
+var import_mini93 = require("zod/mini");
+var importOptionsSchema = import_mini93.z.object({
+  target: import_mini93.z.string(),
+  features: import_mini93.z.optional(import_mini93.z.array(import_mini93.z.string())),
+  global: import_mini93.z.optional(import_mini93.z.boolean())
 });
 async function executeImport(options) {
   try {
@@ -30179,7 +30219,7 @@ var importTools = {
 
 // src/mcp/mcp.ts
 var import_node_path171 = require("path");
-var import_mini93 = require("zod/mini");
+var import_mini94 = require("zod/mini");
 var maxMcpSizeBytes = 1024 * 1024;
 async function getMcpFile() {
   try {
@@ -30281,11 +30321,11 @@ async function deleteMcpFile() {
   }
 }
 var mcpToolSchemas = {
-  getMcpFile: import_mini93.z.object({}),
-  putMcpFile: import_mini93.z.object({
-    content: import_mini93.z.string()
+  getMcpFile: import_mini94.z.object({}),
+  putMcpFile: import_mini94.z.object({
+    content: import_mini94.z.string()
   }),
-  deleteMcpFile: import_mini93.z.object({})
+  deleteMcpFile: import_mini94.z.object({})
 };
 var mcpTools = {
   getMcpFile: {
@@ -30319,7 +30359,7 @@ var mcpTools = {
 
 // src/mcp/permissions.ts
 var import_node_path172 = require("path");
-var import_mini94 = require("zod/mini");
+var import_mini95 = require("zod/mini");
 var maxPermissionsSizeBytes = 1024 * 1024;
 async function getPermissionsFile() {
   try {
@@ -30408,11 +30448,11 @@ async function deletePermissionsFile() {
   }
 }
 var permissionsToolSchemas = {
-  getPermissionsFile: import_mini94.z.object({}),
-  putPermissionsFile: import_mini94.z.object({
-    content: import_mini94.z.string()
+  getPermissionsFile: import_mini95.z.object({}),
+  putPermissionsFile: import_mini95.z.object({
+    content: import_mini95.z.string()
   }),
-  deletePermissionsFile: import_mini94.z.object({})
+  deletePermissionsFile: import_mini95.z.object({})
 };
 var permissionsTools = {
   getPermissionsFile: {
@@ -30446,7 +30486,7 @@ var permissionsTools = {
 
 // src/mcp/rules.ts
 var import_node_path173 = require("path");
-var import_mini95 = require("zod/mini");
+var import_mini96 = require("zod/mini");
 var logger2 = new ConsoleLogger({ verbose: false, silent: true });
 var maxRuleSizeBytes = 1024 * 1024;
 var maxRulesCount = 1e3;
@@ -30570,17 +30610,17 @@ async function deleteRule({ relativePathFromCwd }) {
   }
 }
 var ruleToolSchemas = {
-  listRules: import_mini95.z.object({}),
-  getRule: import_mini95.z.object({
-    relativePathFromCwd: import_mini95.z.string()
+  listRules: import_mini96.z.object({}),
+  getRule: import_mini96.z.object({
+    relativePathFromCwd: import_mini96.z.string()
   }),
-  putRule: import_mini95.z.object({
-    relativePathFromCwd: import_mini95.z.string(),
+  putRule: import_mini96.z.object({
+    relativePathFromCwd: import_mini96.z.string(),
     frontmatter: RulesyncRuleFrontmatterSchema,
-    body: import_mini95.z.string()
+    body: import_mini96.z.string()
   }),
-  deleteRule: import_mini95.z.object({
-    relativePathFromCwd: import_mini95.z.string()
+  deleteRule: import_mini96.z.object({
+    relativePathFromCwd: import_mini96.z.string()
   })
 };
 var ruleTools = {
@@ -30629,7 +30669,7 @@ var ruleTools = {
 
 // src/mcp/skills.ts
 var import_node_path174 = require("path");
-var import_mini96 = require("zod/mini");
+var import_mini97 = require("zod/mini");
 var logger3 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSkillSizeBytes = 1024 * 1024;
 var maxSkillsCount = 1e3;
@@ -30802,23 +30842,23 @@ async function deleteSkill({
     );
   }
 }
-var McpSkillFileSchema = import_mini96.z.object({
-  name: import_mini96.z.string(),
-  body: import_mini96.z.string()
+var McpSkillFileSchema = import_mini97.z.object({
+  name: import_mini97.z.string(),
+  body: import_mini97.z.string()
 });
 var skillToolSchemas = {
-  listSkills: import_mini96.z.object({}),
-  getSkill: import_mini96.z.object({
-    relativeDirPathFromCwd: import_mini96.z.string()
+  listSkills: import_mini97.z.object({}),
+  getSkill: import_mini97.z.object({
+    relativeDirPathFromCwd: import_mini97.z.string()
   }),
-  putSkill: import_mini96.z.object({
-    relativeDirPathFromCwd: import_mini96.z.string(),
+  putSkill: import_mini97.z.object({
+    relativeDirPathFromCwd: import_mini97.z.string(),
     frontmatter: RulesyncSkillFrontmatterSchema,
-    body: import_mini96.z.string(),
-    otherFiles: import_mini96.z.optional(import_mini96.z.array(McpSkillFileSchema))
+    body: import_mini97.z.string(),
+    otherFiles: import_mini97.z.optional(import_mini97.z.array(McpSkillFileSchema))
   }),
-  deleteSkill: import_mini96.z.object({
-    relativeDirPathFromCwd: import_mini96.z.string()
+  deleteSkill: import_mini97.z.object({
+    relativeDirPathFromCwd: import_mini97.z.string()
   })
 };
 var skillTools = {
@@ -30868,7 +30908,7 @@ var skillTools = {
 
 // src/mcp/subagents.ts
 var import_node_path175 = require("path");
-var import_mini97 = require("zod/mini");
+var import_mini98 = require("zod/mini");
 var logger4 = new ConsoleLogger({ verbose: false, silent: true });
 var maxSubagentSizeBytes = 1024 * 1024;
 var maxSubagentsCount = 1e3;
@@ -30997,17 +31037,17 @@ async function deleteSubagent({ relativePathFromCwd }) {
   }
 }
 var subagentToolSchemas = {
-  listSubagents: import_mini97.z.object({}),
-  getSubagent: import_mini97.z.object({
-    relativePathFromCwd: import_mini97.z.string()
+  listSubagents: import_mini98.z.object({}),
+  getSubagent: import_mini98.z.object({
+    relativePathFromCwd: import_mini98.z.string()
   }),
-  putSubagent: import_mini97.z.object({
-    relativePathFromCwd: import_mini97.z.string(),
+  putSubagent: import_mini98.z.object({
+    relativePathFromCwd: import_mini98.z.string(),
     frontmatter: RulesyncSubagentFrontmatterSchema,
-    body: import_mini97.z.string()
+    body: import_mini98.z.string()
   }),
-  deleteSubagent: import_mini97.z.object({
-    relativePathFromCwd: import_mini97.z.string()
+  deleteSubagent: import_mini98.z.object({
+    relativePathFromCwd: import_mini98.z.string()
   })
 };
 var subagentTools = {
@@ -31055,7 +31095,7 @@ var subagentTools = {
 };
 
 // src/mcp/tools.ts
-var rulesyncFeatureSchema = import_mini98.z.enum([
+var rulesyncFeatureSchema = import_mini99.z.enum([
   "rule",
   "command",
   "subagent",
@@ -31068,22 +31108,22 @@ var rulesyncFeatureSchema = import_mini98.z.enum([
   "import",
   "convert"
 ]);
-var rulesyncOperationSchema = import_mini98.z.enum(["list", "get", "put", "delete", "run"]);
-var skillFileSchema = import_mini98.z.object({
-  name: import_mini98.z.string(),
-  body: import_mini98.z.string()
+var rulesyncOperationSchema = import_mini99.z.enum(["list", "get", "put", "delete", "run"]);
+var skillFileSchema = import_mini99.z.object({
+  name: import_mini99.z.string(),
+  body: import_mini99.z.string()
 });
-var rulesyncToolSchema = import_mini98.z.object({
+var rulesyncToolSchema = import_mini99.z.object({
   feature: rulesyncFeatureSchema,
   operation: rulesyncOperationSchema,
-  targetPathFromCwd: import_mini98.z.optional(import_mini98.z.string()),
-  frontmatter: import_mini98.z.optional(import_mini98.z.unknown()),
-  body: import_mini98.z.optional(import_mini98.z.string()),
-  otherFiles: import_mini98.z.optional(import_mini98.z.array(skillFileSchema)),
-  content: import_mini98.z.optional(import_mini98.z.string()),
-  generateOptions: import_mini98.z.optional(generateOptionsSchema),
-  importOptions: import_mini98.z.optional(importOptionsSchema),
-  convertOptions: import_mini98.z.optional(convertOptionsSchema)
+  targetPathFromCwd: import_mini99.z.optional(import_mini99.z.string()),
+  frontmatter: import_mini99.z.optional(import_mini99.z.unknown()),
+  body: import_mini99.z.optional(import_mini99.z.string()),
+  otherFiles: import_mini99.z.optional(import_mini99.z.array(skillFileSchema)),
+  content: import_mini99.z.optional(import_mini99.z.string()),
+  generateOptions: import_mini99.z.optional(generateOptionsSchema),
+  importOptions: import_mini99.z.optional(importOptionsSchema),
+  convertOptions: import_mini99.z.optional(convertOptionsSchema)
 });
 var supportedOperationsByFeature = {
   rule: ["list", "get", "put", "delete"],
@@ -31753,7 +31793,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.17.0";
+var getVersion = () => "8.18.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }