rulesync 7.11.0 → 7.12.1

package/dist/cli/index.cjs

@@ -433,10 +433,9 @@ function parseFrontmatter(content, filePath) {
     body = result.content;
   } catch (error) {
     if (filePath) {
-      throw new Error(
-        `Failed to parse frontmatter in ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
-        { cause: error }
-      );
+      throw new Error(`Failed to parse frontmatter in ${filePath}: ${formatError(error)}`, {
+        cause: error
+      });
     }
     throw error;
   }
@@ -609,7 +608,7 @@ var ToolCommand = class extends AiFile {
 
 // src/features/commands/simulated-command.ts
 var SimulatedCommandFrontmatterSchema = import_mini2.z.object({
-  description: import_mini2.z.string()
+  description: import_mini2.z.optional(import_mini2.z.string())
 });
 var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
   frontmatter;
@@ -829,7 +828,7 @@ var RulesyncTargetsSchema = import_mini3.z.array(import_mini3.z.enum(ALL_TOOL_TA
 // src/features/commands/rulesync-command.ts
 var RulesyncCommandFrontmatterSchema = import_mini4.z.looseObject({
   targets: import_mini4.z._default(RulesyncTargetsSchema, ["*"]),
-  description: import_mini4.z.string()
+  description: import_mini4.z.optional(import_mini4.z.string())
 });
 var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
   frontmatter;
@@ -917,7 +916,7 @@ var AntigravityWorkflowFrontmatterSchema = import_mini5.z.looseObject({
   turbo: import_mini5.z.optional(import_mini5.z.boolean())
 });
 var AntigravityCommandFrontmatterSchema = import_mini5.z.looseObject({
-  description: import_mini5.z.string(),
+  description: import_mini5.z.optional(import_mini5.z.string()),
   // Support for workflow-specific configuration
   ...AntigravityWorkflowFrontmatterSchema.shape
 });
@@ -1090,7 +1089,7 @@ ${body}${turboDirective}`;
 var import_node_path8 = require("path");
 var import_mini6 = require("zod/mini");
 var ClaudecodeCommandFrontmatterSchema = import_mini6.z.looseObject({
-  description: import_mini6.z.string(),
+  description: import_mini6.z.optional(import_mini6.z.string()),
   "allowed-tools": import_mini6.z.optional(import_mini6.z.union([import_mini6.z.string(), import_mini6.z.array(import_mini6.z.string())])),
   "argument-hint": import_mini6.z.optional(import_mini6.z.string()),
   model: import_mini6.z.optional(import_mini6.z.string()),
@@ -1245,8 +1244,7 @@ var ClineCommand = class _ClineCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: process.cwd(),
@@ -1331,8 +1329,7 @@ var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: ".",
@@ -1410,7 +1407,7 @@ var import_node_path11 = require("path");
 var import_mini7 = require("zod/mini");
 var CopilotCommandFrontmatterSchema = import_mini7.z.looseObject({
   mode: import_mini7.z.optional(import_mini7.z.string()),
-  description: import_mini7.z.string()
+  description: import_mini7.z.optional(import_mini7.z.string())
 });
 var CopilotCommand = class _CopilotCommand extends ToolCommand {
   frontmatter;
@@ -1593,7 +1590,7 @@ var CursorCommand = class _CursorCommand extends ToolCommand {
     return this.frontmatter;
   }
   toRulesyncCommand() {
-    const { description = "", ...restFields } = this.frontmatter;
+    const { description, ...restFields } = this.frontmatter;
     const rulesyncFrontmatter = {
       targets: ["*"],
       description,
@@ -1787,7 +1784,7 @@ var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
       }
       return {
         ...result.data,
-        description: result.data.description || ""
+        description: result.data.description
       };
     } catch (error) {
       throw new Error(
@@ -1809,7 +1806,7 @@ var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
     const { description, prompt: _prompt, ...restFields } = this.frontmatter;
     const rulesyncFrontmatter = {
       targets: ["geminicli"],
-      description: description ?? "",
+      description,
       // Preserve extra fields in geminicli section (excluding prompt which is the body)
       ...Object.keys(restFields).length > 0 && { geminicli: restFields }
     };
@@ -1838,8 +1835,9 @@ var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
       prompt: rulesyncCommand.getBody(),
       ...geminicliFields
     };
-    const tomlContent = `description = "${geminiFrontmatter.description}"
-prompt = """
+    const descriptionLine = geminiFrontmatter.description !== void 0 ? `description = "${geminiFrontmatter.description}"
+` : "";
+    const tomlContent = `${descriptionLine}prompt = """
 ${geminiFrontmatter.prompt}
 """`;
     const paths = this.getSettablePaths({ global });
@@ -1909,8 +1907,7 @@ var KiloCommand = class _KiloCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: process.cwd(),
@@ -1990,8 +1987,7 @@ var KiroCommand = class _KiroCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: process.cwd(),
@@ -2065,7 +2061,7 @@ var KiroCommand = class _KiroCommand extends ToolCommand {
 var import_node_path17 = require("path");
 var import_mini10 = require("zod/mini");
 var OpenCodeCommandFrontmatterSchema = import_mini10.z.looseObject({
-  description: import_mini10.z.string(),
+  description: import_mini10.z.optional(import_mini10.z.string()),
   agent: (0, import_mini10.optional)(import_mini10.z.string()),
   subtask: (0, import_mini10.optional)(import_mini10.z.boolean()),
   model: (0, import_mini10.optional)(import_mini10.z.string())
@@ -2205,7 +2201,7 @@ var OpenCodeCommand = class _OpenCodeCommand extends ToolCommand {
 var import_node_path18 = require("path");
 var import_mini11 = require("zod/mini");
 var RooCommandFrontmatterSchema = import_mini11.z.looseObject({
-  description: import_mini11.z.string(),
+  description: import_mini11.z.optional(import_mini11.z.string()),
   "argument-hint": (0, import_mini11.optional)(import_mini11.z.string())
 });
 var RooCommand = class _RooCommand extends ToolCommand {
@@ -2744,7 +2740,7 @@ var HookDefinitionSchema = import_mini13.z.looseObject({
   type: import_mini13.z.optional(import_mini13.z.enum(["command", "prompt"])),
   timeout: import_mini13.z.optional(import_mini13.z.number()),
   matcher: import_mini13.z.optional(safeString),
-  prompt: import_mini13.z.optional(import_mini13.z.string()),
+  prompt: import_mini13.z.optional(safeString),
   loop_limit: import_mini13.z.optional(import_mini13.z.nullable(import_mini13.z.number())),
   name: import_mini13.z.optional(safeString),
   description: import_mini13.z.optional(safeString)
@@ -2796,7 +2792,7 @@ var OPENCODE_HOOK_EVENTS = [
 var COPILOT_HOOK_EVENTS = [
   "sessionStart",
   "sessionEnd",
-  "afterSubmitPrompt",
+  "beforeSubmitPrompt",
   "preToolUse",
   "postToolUse",
   "afterError"
@@ -2907,7 +2903,7 @@ var CANONICAL_TO_OPENCODE_EVENT_NAMES = {
 var CANONICAL_TO_COPILOT_EVENT_NAMES = {
   sessionStart: "sessionStart",
   sessionEnd: "sessionEnd",
-  afterSubmitPrompt: "userPromptSubmitted",
+  beforeSubmitPrompt: "userPromptSubmitted",
   preToolUse: "preToolUse",
   postToolUse: "postToolUse",
   afterError: "errorOccurred"
@@ -2935,6 +2931,104 @@ var GEMINICLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(
 // src/features/hooks/claudecode-hooks.ts
 var import_node_path21 = require("path");
 
+// src/features/hooks/tool-hooks-converter.ts
+function isToolMatcherEntry(x) {
+  if (x === null || typeof x !== "object") {
+    return false;
+  }
+  if ("matcher" in x && typeof x.matcher !== "string") {
+    return false;
+  }
+  if ("hooks" in x && !Array.isArray(x.hooks)) {
+    return false;
+  }
+  return true;
+}
+function canonicalToToolHooks({
+  config,
+  toolOverrideHooks,
+  converterConfig
+}) {
+  const supported = new Set(converterConfig.supportedEvents);
+  const sharedHooks = {};
+  for (const [event, defs] of Object.entries(config.hooks)) {
+    if (supported.has(event)) {
+      sharedHooks[event] = defs;
+    }
+  }
+  const effectiveHooks = {
+    ...sharedHooks,
+    ...toolOverrideHooks
+  };
+  const result = {};
+  for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
+    const toolEventName = converterConfig.canonicalToToolEventNames[eventName] ?? eventName;
+    const byMatcher = /* @__PURE__ */ new Map();
+    for (const def of definitions) {
+      const key = def.matcher ?? "";
+      const list = byMatcher.get(key);
+      if (list) list.push(def);
+      else byMatcher.set(key, [def]);
+    }
+    const entries = [];
+    for (const [matcherKey, defs] of byMatcher) {
+      const hooks = defs.map((def) => {
+        const command = def.command !== void 0 && def.command !== null && !def.command.startsWith("$") ? `${converterConfig.projectDirVar}/${def.command.replace(/^\.\//, "")}` : def.command;
+        return {
+          type: def.type ?? "command",
+          ...command !== void 0 && command !== null && { command },
+          ...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
+          ...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt }
+        };
+      });
+      entries.push(matcherKey ? { matcher: matcherKey, hooks } : { hooks });
+    }
+    result[toolEventName] = entries;
+  }
+  return result;
+}
+function toolHooksToCanonical({
+  hooks,
+  converterConfig
+}) {
+  if (hooks === null || hooks === void 0 || typeof hooks !== "object") {
+    return {};
+  }
+  const canonical = {};
+  for (const [toolEventName, matcherEntries] of Object.entries(hooks)) {
+    const eventName = converterConfig.toolToCanonicalEventNames[toolEventName] ?? toolEventName;
+    if (!Array.isArray(matcherEntries)) continue;
+    const defs = [];
+    for (const rawEntry of matcherEntries) {
+      if (!isToolMatcherEntry(rawEntry)) continue;
+      const hookDefs = rawEntry.hooks ?? [];
+      for (const h of hookDefs) {
+        const cmd = typeof h.command === "string" ? h.command : void 0;
+        const command = typeof cmd === "string" && cmd.includes(`${converterConfig.projectDirVar}/`) ? cmd.replace(
+          new RegExp(
+            `^${converterConfig.projectDirVar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\/?`
+          ),
+          "./"
+        ) : cmd;
+        const hookType = h.type === "command" || h.type === "prompt" ? h.type : "command";
+        const timeout = typeof h.timeout === "number" ? h.timeout : void 0;
+        const prompt = typeof h.prompt === "string" ? h.prompt : void 0;
+        defs.push({
+          type: hookType,
+          ...command !== void 0 && command !== null && { command },
+          ...timeout !== void 0 && timeout !== null && { timeout },
+          ...prompt !== void 0 && prompt !== null && { prompt },
+          ...rawEntry.matcher !== void 0 && rawEntry.matcher !== null && rawEntry.matcher !== "" && { matcher: rawEntry.matcher }
+        });
+      }
+    }
+    if (defs.length > 0) {
+      canonical[eventName] = defs;
+    }
+  }
+  return canonical;
+}
+
 // src/types/tool-file.ts
 var ToolFile = class extends AiFile {
 };
@@ -3025,91 +3119,12 @@ var ToolHooks = class extends ToolFile {
 };
 
 // src/features/hooks/claudecode-hooks.ts
-function canonicalToClaudeHooks(config) {
-  const claudeSupported = new Set(CLAUDE_HOOK_EVENTS);
-  const sharedHooks = {};
-  for (const [event, defs] of Object.entries(config.hooks)) {
-    if (claudeSupported.has(event)) {
-      sharedHooks[event] = defs;
-    }
-  }
-  const effectiveHooks = {
-    ...sharedHooks,
-    ...config.claudecode?.hooks
-  };
-  const claude = {};
-  for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
-    const claudeEventName = CANONICAL_TO_CLAUDE_EVENT_NAMES[eventName] ?? eventName;
-    const byMatcher = /* @__PURE__ */ new Map();
-    for (const def of definitions) {
-      const key = def.matcher ?? "";
-      const list = byMatcher.get(key);
-      if (list) list.push(def);
-      else byMatcher.set(key, [def]);
-    }
-    const entries = [];
-    for (const [matcherKey, defs] of byMatcher) {
-      const hooks = defs.map((def) => {
-        const command = def.command !== void 0 && def.command !== null && !def.command.startsWith("$") ? `$CLAUDE_PROJECT_DIR/${def.command.replace(/^\.\//, "")}` : def.command;
-        return {
-          type: def.type ?? "command",
-          ...command !== void 0 && command !== null && { command },
-          ...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
-          ...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt }
-        };
-      });
-      entries.push(matcherKey ? { matcher: matcherKey, hooks } : { hooks });
-    }
-    claude[claudeEventName] = entries;
-  }
-  return claude;
-}
-function isClaudeMatcherEntry(x) {
-  if (x === null || typeof x !== "object") {
-    return false;
-  }
-  if ("matcher" in x && typeof x.matcher !== "string") {
-    return false;
-  }
-  if ("hooks" in x && !Array.isArray(x.hooks)) {
-    return false;
-  }
-  return true;
-}
-function claudeHooksToCanonical(claudeHooks) {
-  if (claudeHooks === null || claudeHooks === void 0 || typeof claudeHooks !== "object") {
-    return {};
-  }
-  const canonical = {};
-  for (const [claudeEventName, matcherEntries] of Object.entries(claudeHooks)) {
-    const eventName = CLAUDE_TO_CANONICAL_EVENT_NAMES[claudeEventName] ?? claudeEventName;
-    if (!Array.isArray(matcherEntries)) continue;
-    const defs = [];
-    for (const rawEntry of matcherEntries) {
-      if (!isClaudeMatcherEntry(rawEntry)) continue;
-      const entry = rawEntry;
-      const hooks = entry.hooks ?? [];
-      for (const h of hooks) {
-        const cmd = typeof h.command === "string" ? h.command : void 0;
-        const command = typeof cmd === "string" && cmd.includes("$CLAUDE_PROJECT_DIR/") ? cmd.replace(/^\$CLAUDE_PROJECT_DIR\/?/, "./") : cmd;
-        const hookType = h.type === "command" || h.type === "prompt" ? h.type : "command";
-        const timeout = typeof h.timeout === "number" ? h.timeout : void 0;
-        const prompt = typeof h.prompt === "string" ? h.prompt : void 0;
-        defs.push({
-          type: hookType,
-          ...command !== void 0 && command !== null && { command },
-          ...timeout !== void 0 && timeout !== null && { timeout },
-          ...prompt !== void 0 && prompt !== null && { prompt },
-          ...entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "" && { matcher: entry.matcher }
-        });
-      }
-    }
-    if (defs.length > 0) {
-      canonical[eventName] = defs;
-    }
-  }
-  return canonical;
-}
+var CLAUDE_CONVERTER_CONFIG = {
+  supportedEvents: CLAUDE_HOOK_EVENTS,
+  canonicalToToolEventNames: CANONICAL_TO_CLAUDE_EVENT_NAMES,
+  toolToCanonicalEventNames: CLAUDE_TO_CANONICAL_EVENT_NAMES,
+  projectDirVar: "$CLAUDE_PROJECT_DIR"
+};
 var ClaudecodeHooks = class _ClaudecodeHooks extends ToolHooks {
   constructor(params) {
     super({
@@ -3161,7 +3176,11 @@ var ClaudecodeHooks = class _ClaudecodeHooks extends ToolHooks {
       );
     }
     const config = rulesyncHooks.getJson();
-    const claudeHooks = canonicalToClaudeHooks(config);
+    const claudeHooks = canonicalToToolHooks({
+      config,
+      toolOverrideHooks: config.claudecode?.hooks,
+      converterConfig: CLAUDE_CONVERTER_CONFIG
+    });
     const merged = { ...settings, hooks: claudeHooks };
     const fileContent = JSON.stringify(merged, null, 2);
     return new _ClaudecodeHooks({
@@ -3184,7 +3203,10 @@ var ClaudecodeHooks = class _ClaudecodeHooks extends ToolHooks {
         }
       );
     }
-    const hooks = claudeHooksToCanonical(settings.hooks);
+    const hooks = toolHooksToCanonical({
+      hooks: settings.hooks,
+      converterConfig: CLAUDE_CONVERTER_CONFIG
+    });
     return this.toRulesyncHooksDefault({
       fileContent: JSON.stringify({ version: 1, hooks }, null, 2)
     });
@@ -3493,91 +3515,12 @@ var CursorHooks = class _CursorHooks extends ToolHooks {
 
 // src/features/hooks/factorydroid-hooks.ts
 var import_node_path24 = require("path");
-function canonicalToFactorydroidHooks(config) {
-  const supported = new Set(FACTORYDROID_HOOK_EVENTS);
-  const sharedHooks = {};
-  for (const [event, defs] of Object.entries(config.hooks)) {
-    if (supported.has(event)) {
-      sharedHooks[event] = defs;
-    }
-  }
-  const effectiveHooks = {
-    ...sharedHooks,
-    ...config.factorydroid?.hooks
-  };
-  const result = {};
-  for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
-    const pascalEventName = CANONICAL_TO_FACTORYDROID_EVENT_NAMES[eventName] ?? eventName;
-    const byMatcher = /* @__PURE__ */ new Map();
-    for (const def of definitions) {
-      const key = def.matcher ?? "";
-      const list = byMatcher.get(key);
-      if (list) list.push(def);
-      else byMatcher.set(key, [def]);
-    }
-    const entries = [];
-    for (const [matcherKey, defs] of byMatcher) {
-      const hooks = defs.map((def) => {
-        const command = def.command !== void 0 && def.command !== null && !def.command.startsWith("$") ? `$FACTORY_PROJECT_DIR/${def.command.replace(/^\.\//, "")}` : def.command;
-        return {
-          type: def.type ?? "command",
-          ...command !== void 0 && command !== null && { command },
-          ...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
-          ...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt }
-        };
-      });
-      entries.push(matcherKey ? { matcher: matcherKey, hooks } : { hooks });
-    }
-    result[pascalEventName] = entries;
-  }
-  return result;
-}
-function isFactorydroidMatcherEntry(x) {
-  if (x === null || typeof x !== "object") {
-    return false;
-  }
-  if ("matcher" in x && typeof x.matcher !== "string") {
-    return false;
-  }
-  if ("hooks" in x && !Array.isArray(x.hooks)) {
-    return false;
-  }
-  return true;
-}
-function factorydroidHooksToCanonical(hooks) {
-  if (hooks === null || hooks === void 0 || typeof hooks !== "object") {
-    return {};
-  }
-  const canonical = {};
-  for (const [pascalEventName, matcherEntries] of Object.entries(hooks)) {
-    const eventName = FACTORYDROID_TO_CANONICAL_EVENT_NAMES[pascalEventName] ?? pascalEventName;
-    if (!Array.isArray(matcherEntries)) continue;
-    const defs = [];
-    for (const rawEntry of matcherEntries) {
-      if (!isFactorydroidMatcherEntry(rawEntry)) continue;
-      const entry = rawEntry;
-      const hookDefs = entry.hooks ?? [];
-      for (const h of hookDefs) {
-        const cmd = typeof h.command === "string" ? h.command : void 0;
-        const command = typeof cmd === "string" && cmd.includes("$FACTORY_PROJECT_DIR/") ? cmd.replace(/^\$FACTORY_PROJECT_DIR\/?/, "./") : cmd;
-        const hookType = h.type === "command" || h.type === "prompt" ? h.type : "command";
-        const timeout = typeof h.timeout === "number" ? h.timeout : void 0;
-        const prompt = typeof h.prompt === "string" ? h.prompt : void 0;
-        defs.push({
-          type: hookType,
-          ...command !== void 0 && command !== null && { command },
-          ...timeout !== void 0 && timeout !== null && { timeout },
-          ...prompt !== void 0 && prompt !== null && { prompt },
-          ...entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "" && { matcher: entry.matcher }
-        });
-      }
-    }
-    if (defs.length > 0) {
-      canonical[eventName] = defs;
-    }
-  }
-  return canonical;
-}
+var FACTORYDROID_CONVERTER_CONFIG = {
+  supportedEvents: FACTORYDROID_HOOK_EVENTS,
+  canonicalToToolEventNames: CANONICAL_TO_FACTORYDROID_EVENT_NAMES,
+  toolToCanonicalEventNames: FACTORYDROID_TO_CANONICAL_EVENT_NAMES,
+  projectDirVar: "$FACTORY_PROJECT_DIR"
+};
 var FactorydroidHooks = class _FactorydroidHooks extends ToolHooks {
   constructor(params) {
     super({
@@ -3629,7 +3572,11 @@ var FactorydroidHooks = class _FactorydroidHooks extends ToolHooks {
       );
     }
     const config = rulesyncHooks.getJson();
-    const factorydroidHooks = canonicalToFactorydroidHooks(config);
+    const factorydroidHooks = canonicalToToolHooks({
+      config,
+      toolOverrideHooks: config.factorydroid?.hooks,
+      converterConfig: FACTORYDROID_CONVERTER_CONFIG
+    });
     const merged = { ...settings, hooks: factorydroidHooks };
     const fileContent = JSON.stringify(merged, null, 2);
     return new _FactorydroidHooks({
@@ -3652,7 +3599,10 @@ var FactorydroidHooks = class _FactorydroidHooks extends ToolHooks {
         }
       );
     }
-    const hooks = factorydroidHooksToCanonical(settings.hooks);
+    const hooks = toolHooksToCanonical({
+      hooks: settings.hooks,
+      converterConfig: FACTORYDROID_CONVERTER_CONFIG
+    });
     return this.toRulesyncHooksDefault({
       fileContent: JSON.stringify({ version: 1, hooks }, null, 2)
     });
@@ -7780,7 +7730,8 @@ var RulesyncSkillFrontmatterSchemaInternal = import_mini23.z.looseObject({
   targets: import_mini23.z._default(RulesyncTargetsSchema, ["*"]),
   claudecode: import_mini23.z.optional(
     import_mini23.z.looseObject({
-      "allowed-tools": import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string()))
+      "allowed-tools": import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string())),
+      model: import_mini23.z.optional(import_mini23.z.string())
     })
   ),
   codexcli: import_mini23.z.optional(
@@ -8216,7 +8167,8 @@ var import_mini26 = require("zod/mini");
 var ClaudecodeSkillFrontmatterSchema = import_mini26.z.looseObject({
   name: import_mini26.z.string(),
   description: import_mini26.z.string(),
-  "allowed-tools": import_mini26.z.optional(import_mini26.z.array(import_mini26.z.string()))
+  "allowed-tools": import_mini26.z.optional(import_mini26.z.array(import_mini26.z.string())),
+  model: import_mini26.z.optional(import_mini26.z.string())
 });
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
@@ -8282,15 +8234,15 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   }
   toRulesyncSkill() {
     const frontmatter = this.getFrontmatter();
+    const claudecodeSection = {
+      ...frontmatter["allowed-tools"] && { "allowed-tools": frontmatter["allowed-tools"] },
+      ...frontmatter.model && { model: frontmatter.model }
+    };
     const rulesyncFrontmatter = {
       name: frontmatter.name,
       description: frontmatter.description,
       targets: ["*"],
-      ...frontmatter["allowed-tools"] && {
-        claudecode: {
-          "allowed-tools": frontmatter["allowed-tools"]
-        }
-      }
+      ...Object.keys(claudecodeSection).length > 0 && { claudecode: claudecodeSection }
     };
     return new RulesyncSkill({
       baseDir: this.baseDir,
@@ -8312,7 +8264,12 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
     const claudecodeFrontmatter = {
       name: rulesyncFrontmatter.name,
       description: rulesyncFrontmatter.description,
-      "allowed-tools": rulesyncFrontmatter.claudecode?.["allowed-tools"]
+      ...rulesyncFrontmatter.claudecode?.["allowed-tools"] && {
+        "allowed-tools": rulesyncFrontmatter.claudecode["allowed-tools"]
+      },
+      ...rulesyncFrontmatter.claudecode?.model && {
+        model: rulesyncFrontmatter.claudecode.model
+      }
     };
     const settablePaths = _ClaudecodeSkill.getSettablePaths({ global });
     return new _ClaudecodeSkill({
@@ -10442,7 +10399,7 @@ var ToolSubagent = class extends ToolFile {
 // src/features/subagents/simulated-subagent.ts
 var SimulatedSubagentFrontmatterSchema = import_mini38.z.object({
   name: import_mini38.z.string(),
-  description: import_mini38.z.string()
+  description: import_mini38.z.optional(import_mini38.z.string())
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -10666,7 +10623,7 @@ var import_mini39 = require("zod/mini");
 var RulesyncSubagentFrontmatterSchema = import_mini39.z.looseObject({
   targets: import_mini39.z._default(RulesyncTargetsSchema, ["*"]),
   name: import_mini39.z.string(),
-  description: import_mini39.z.string()
+  description: import_mini39.z.optional(import_mini39.z.string())
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -10737,7 +10694,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 // src/features/subagents/claudecode-subagent.ts
 var ClaudecodeSubagentFrontmatterSchema = import_mini40.z.looseObject({
   name: import_mini40.z.string(),
-  description: import_mini40.z.string(),
+  description: import_mini40.z.optional(import_mini40.z.string()),
   model: import_mini40.z.optional(import_mini40.z.string()),
   tools: import_mini40.z.optional(import_mini40.z.union([import_mini40.z.string(), import_mini40.z.array(import_mini40.z.string())])),
   permissionMode: import_mini40.z.optional(import_mini40.z.string()),
@@ -10947,7 +10904,7 @@ var CodexCliSubagent = class _CodexCliSubagent extends ToolSubagent {
     const rulesyncFrontmatter = {
       targets: ["codexcli"],
       name,
-      description: description ?? "",
+      description,
       // Only include codexcli section if there are fields
       ...Object.keys(codexcliSection).length > 0 && { codexcli: codexcliSection }
     };
@@ -11060,7 +11017,7 @@ var import_mini42 = require("zod/mini");
 var REQUIRED_TOOL = "agent/runSubagent";
 var CopilotSubagentFrontmatterSchema = import_mini42.z.looseObject({
   name: import_mini42.z.string(),
-  description: import_mini42.z.string(),
+  description: import_mini42.z.optional(import_mini42.z.string()),
   tools: import_mini42.z.optional(import_mini42.z.union([import_mini42.z.string(), import_mini42.z.array(import_mini42.z.string())]))
 });
 var normalizeTools = (tools) => {
@@ -11225,7 +11182,7 @@ var import_node_path85 = require("path");
 var import_mini43 = require("zod/mini");
 var CursorSubagentFrontmatterSchema = import_mini43.z.looseObject({
   name: import_mini43.z.string(),
-  description: import_mini43.z.string()
+  description: import_mini43.z.optional(import_mini43.z.string())
 });
 var CursorSubagent = class _CursorSubagent extends ToolSubagent {
   frontmatter;
@@ -11430,7 +11387,7 @@ var KiroSubagent = class _KiroSubagent extends ToolSubagent {
     const rulesyncFrontmatter = {
       targets: ["kiro"],
       name,
-      description: description ?? "",
+      description: description ?? void 0,
       // Only include kiro section if there are fields
       ...Object.keys(kiroSection).length > 0 && { kiro: kiroSection }
     };
@@ -11541,7 +11498,7 @@ var KiroSubagent = class _KiroSubagent extends ToolSubagent {
 var import_node_path87 = require("path");
 var import_mini45 = require("zod/mini");
 var OpenCodeSubagentFrontmatterSchema = import_mini45.z.looseObject({
-  description: import_mini45.z.string(),
+  description: import_mini45.z.optional(import_mini45.z.string()),
   mode: import_mini45.z._default(import_mini45.z.string(), "subagent"),
   name: import_mini45.z.optional(import_mini45.z.string())
 });
@@ -12371,7 +12328,7 @@ var globStrategy = {
   },
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: parseGlobsString(frontmatter.globs),
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12383,7 +12340,7 @@ var manualStrategy = {
   }),
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: [],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12395,7 +12352,7 @@ var alwaysOnStrategy = {
   }),
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: ["**/*"],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12408,7 +12365,7 @@ var modelDecisionStrategy = {
   }),
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: [],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12423,7 +12380,7 @@ var unknownStrategy = {
   },
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12445,7 +12402,7 @@ var inferenceStrategy = {
   },
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12575,7 +12532,6 @@ var AntigravityRule = class _AntigravityRule extends ToolRule {
     const strategy = STRATEGIES.find((s) => s.canHandle(this.frontmatter.trigger));
     let rulesyncData = {
       globs: [],
-      description: "",
       antigravity: this.frontmatter
     };
     if (strategy) {
@@ -12645,7 +12601,6 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
     const rulesyncFrontmatter = {
       root: this.isRoot(),
       targets: ["*"],
-      description: "",
       globs: this.isRoot() ? ["**/*"] : []
     };
     return new RulesyncRule({
@@ -12820,6 +12775,12 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
         relativeDirPath: ".",
         relativeFilePath: "CLAUDE.md"
       },
+      alternativeRoots: [
+        {
+          relativeDirPath: ".claude",
+          relativeFilePath: "CLAUDE.md"
+        }
+      ],
       nonRoot: {
         relativeDirPath: buildToolPath(".claude", "memories", excludeToolDir)
       }
@@ -12829,18 +12790,19 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
     baseDir = process.cwd(),
     relativeFilePath,
     validate = true,
-    global = false
+    global = false,
+    relativeDirPath: overrideDirPath
   }) {
     const paths = this.getSettablePaths({ global });
     const isRoot = relativeFilePath === paths.root.relativeFilePath;
     if (isRoot) {
-      const relativePath2 = paths.root.relativeFilePath;
+      const rootDirPath = overrideDirPath ?? paths.root.relativeDirPath;
       const fileContent2 = await readFileContent(
-        (0, import_node_path95.join)(baseDir, paths.root.relativeDirPath, relativePath2)
+        (0, import_node_path95.join)(baseDir, rootDirPath, paths.root.relativeFilePath)
       );
       return new _ClaudecodeLegacyRule({
         baseDir,
-        relativeDirPath: paths.root.relativeDirPath,
+        relativeDirPath: rootDirPath,
         relativeFilePath: paths.root.relativeFilePath,
         fileContent: fileContent2,
         validate,
@@ -12935,6 +12897,12 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
         relativeDirPath: ".",
         relativeFilePath: "CLAUDE.md"
       },
+      alternativeRoots: [
+        {
+          relativeDirPath: ".claude",
+          relativeFilePath: "CLAUDE.md"
+        }
+      ],
       nonRoot: {
         relativeDirPath: buildToolPath(".claude", "rules", excludeToolDir)
       }
@@ -12967,17 +12935,19 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
     baseDir = process.cwd(),
     relativeFilePath,
     validate = true,
-    global = false
+    global = false,
+    relativeDirPath: overrideDirPath
   }) {
     const paths = this.getSettablePaths({ global });
     const isRoot = relativeFilePath === paths.root.relativeFilePath;
     if (isRoot) {
+      const rootDirPath = overrideDirPath ?? paths.root.relativeDirPath;
       const fileContent2 = await readFileContent(
-        (0, import_node_path96.join)(baseDir, paths.root.relativeDirPath, paths.root.relativeFilePath)
+        (0, import_node_path96.join)(baseDir, rootDirPath, paths.root.relativeFilePath)
       );
       return new _ClaudecodeRule({
         baseDir,
-        relativeDirPath: paths.root.relativeDirPath,
+        relativeDirPath: rootDirPath,
         relativeFilePath: paths.root.relativeFilePath,
         frontmatter: {},
         body: fileContent2.trim(),
@@ -12989,16 +12959,12 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
       throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
     }
     const relativePath = (0, import_node_path96.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path96.join)(baseDir, relativePath));
-    const { frontmatter, body: content } = parseFrontmatter(
-      fileContent,
-      (0, import_node_path96.join)(baseDir, relativePath)
-    );
+    const filePath = (0, import_node_path96.join)(baseDir, relativePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
     const result = ClaudecodeRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path96.join)(baseDir, relativePath)}: ${formatError(result.error)}`
-      );
+      throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
     }
     return new _ClaudecodeRule({
       baseDir,
@@ -13430,7 +13396,8 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     const isRoot = relativeFilePath === paths.root.relativeFilePath;
     if (isRoot) {
       const relativePath2 = (0, import_node_path99.join)(paths.root.relativeDirPath, paths.root.relativeFilePath);
-      const fileContent2 = await readFileContent((0, import_node_path99.join)(baseDir, relativePath2));
+      const filePath2 = (0, import_node_path99.join)(baseDir, relativePath2);
+      const fileContent2 = await readFileContent(filePath2);
       return new _CopilotRule({
         baseDir,
         relativeDirPath: paths.root.relativeDirPath,
@@ -13445,16 +13412,12 @@ var CopilotRule = class _CopilotRule extends ToolRule {
       throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
     }
     const relativePath = (0, import_node_path99.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path99.join)(baseDir, relativePath));
-    const { frontmatter, body: content } = parseFrontmatter(
-      fileContent,
-      (0, import_node_path99.join)(baseDir, relativePath)
-    );
+    const filePath = (0, import_node_path99.join)(baseDir, relativePath);
+    const fileContent = await readFileContent(filePath);
+    const { frontmatter, body: content } = parseFrontmatter(fileContent, filePath);
     const result = CopilotRuleFrontmatterSchema.safeParse(frontmatter);
     if (!result.success) {
-      throw new Error(
-        `Invalid frontmatter in ${(0, import_node_path99.join)(baseDir, relativeFilePath)}: ${formatError(result.error)}`
-      );
+      throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
     }
     return new _CopilotRule({
       baseDir,
@@ -15341,35 +15304,62 @@ var RulesProcessor = class extends FeatureProcessor {
       const settablePaths = factory.class.getSettablePaths({
         global: this.global
       });
+      const resolveRelativeDirPath = (filePath) => {
+        const dirName = (0, import_node_path113.dirname)((0, import_node_path113.relative)(this.baseDir, filePath));
+        return dirName === "" ? "." : dirName;
+      };
+      const findFilesWithFallback = async (primaryGlob, alternativeRoots, buildAltGlob) => {
+        const primaryFilePaths = await findFilesByGlobs(primaryGlob);
+        if (primaryFilePaths.length > 0) {
+          return primaryFilePaths;
+        }
+        if (alternativeRoots) {
+          return findFilesByGlobs(alternativeRoots.map(buildAltGlob));
+        }
+        return [];
+      };
       const rootToolRules = await (async () => {
         if (!settablePaths.root) {
           return [];
         }
-        const rootFilePaths = await findFilesByGlobs(
+        const uniqueRootFilePaths = await findFilesWithFallback(
           (0, import_node_path113.join)(
             this.baseDir,
             settablePaths.root.relativeDirPath ?? ".",
             settablePaths.root.relativeFilePath
-          )
+          ),
+          settablePaths.alternativeRoots,
+          (alt) => (0, import_node_path113.join)(this.baseDir, alt.relativeDirPath, alt.relativeFilePath)
         );
         if (forDeletion) {
-          return rootFilePaths.map(
-            (filePath) => factory.class.forDeletion({
+          return uniqueRootFilePaths.map((filePath) => {
+            const relativeDirPath = resolveRelativeDirPath(filePath);
+            checkPathTraversal({
+              relativePath: relativeDirPath,
+              intendedRootDir: this.baseDir
+            });
+            return factory.class.forDeletion({
               baseDir: this.baseDir,
-              relativeDirPath: settablePaths.root?.relativeDirPath ?? ".",
+              relativeDirPath,
               relativeFilePath: (0, import_node_path113.basename)(filePath),
               global: this.global
-            })
-          ).filter((rule) => rule.isDeletable());
+            });
+          }).filter((rule) => rule.isDeletable());
         }
         return await Promise.all(
-          rootFilePaths.map(
-            (filePath) => factory.class.fromFile({
+          uniqueRootFilePaths.map((filePath) => {
+            const relativeDirPath = resolveRelativeDirPath(filePath);
+            checkPathTraversal({
+              relativePath: relativeDirPath,
+              intendedRootDir: this.baseDir
+            });
+            return factory.class.fromFile({
               baseDir: this.baseDir,
               relativeFilePath: (0, import_node_path113.basename)(filePath),
+              relativeDirPath,
               global: this.global
-            })
-          )
+            });
+          })
         );
       })();
       logger.debug(`Found ${rootToolRules.length} root tool rule files`);
@@ -15383,17 +15373,24 @@ var RulesProcessor = class extends FeatureProcessor {
         if (!settablePaths.root) {
           return [];
         }
-        const localRootFilePaths = await findFilesByGlobs(
-          (0, import_node_path113.join)(this.baseDir, settablePaths.root.relativeDirPath ?? ".", "CLAUDE.local.md")
+        const uniqueLocalRootFilePaths = await findFilesWithFallback(
+          (0, import_node_path113.join)(this.baseDir, settablePaths.root.relativeDirPath ?? ".", "CLAUDE.local.md"),
+          settablePaths.alternativeRoots,
+          (alt) => (0, import_node_path113.join)(this.baseDir, alt.relativeDirPath, "CLAUDE.local.md")
         );
-        return localRootFilePaths.map(
-          (filePath) => factory.class.forDeletion({
+        return uniqueLocalRootFilePaths.map((filePath) => {
+          const relativeDirPath = resolveRelativeDirPath(filePath);
+          checkPathTraversal({
+            relativePath: relativeDirPath,
+            intendedRootDir: this.baseDir
+          });
+          return factory.class.forDeletion({
             baseDir: this.baseDir,
-            relativeDirPath: settablePaths.root?.relativeDirPath ?? ".",
+            relativeDirPath,
             relativeFilePath: (0, import_node_path113.basename)(filePath),
             global: this.global
-          })
-        ).filter((rule) => rule.isDeletable());
+          });
+        }).filter((rule) => rule.isDeletable());
       })();
       logger.debug(`Found ${localRootToolRules.length} local root tool rule files for deletion`);
       const nonRootToolRules = await (async () => {
@@ -16839,6 +16836,14 @@ async function processEmptyFeatureGeneration(params) {
   }
   return { count: totalCount, paths: [], hasDiff };
 }
+function warnUnsupportedTargets(params) {
+  const { config, supportedTargets, featureName } = params;
+  for (const target of config.getTargets()) {
+    if (!supportedTargets.includes(target) && config.getFeatures(target).includes(featureName)) {
+      logger.warn(`Target '${target}' does not support the feature '${featureName}'. Skipping.`);
+    }
+  }
+}
 async function checkRulesyncDirExists(params) {
   return fileExists((0, import_node_path116.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
 }
@@ -16876,10 +16881,9 @@ async function generateRulesCore(params) {
   let totalCount = 0;
   const allPaths = [];
   let hasDiff = false;
-  const toolTargets = (0, import_es_toolkit4.intersection)(
-    config.getTargets(),
-    RulesProcessor.getToolTargets({ global: config.getGlobal() })
-  );
+  const supportedTargets = RulesProcessor.getToolTargets({ global: config.getGlobal() });
+  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedTargets);
+  warnUnsupportedTargets({ config, supportedTargets, featureName: "rules" });
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       if (!config.getFeatures(toolTarget).includes("rules")) {
@@ -16911,13 +16915,19 @@ async function generateRulesCore(params) {
 }
 async function generateIgnoreCore(params) {
   const { config } = params;
+  const supportedIgnoreTargets = IgnoreProcessor.getToolTargets();
+  warnUnsupportedTargets({
+    config,
+    supportedTargets: supportedIgnoreTargets,
+    featureName: "ignore"
+  });
   if (config.getGlobal()) {
     return { count: 0, paths: [], hasDiff: false };
   }
   let totalCount = 0;
   const allPaths = [];
   let hasDiff = false;
-  for (const toolTarget of (0, import_es_toolkit4.intersection)(config.getTargets(), IgnoreProcessor.getToolTargets())) {
+  for (const toolTarget of (0, import_es_toolkit4.intersection)(config.getTargets(), supportedIgnoreTargets)) {
     if (!config.getFeatures(toolTarget).includes("ignore")) {
       continue;
     }
@@ -16961,10 +16971,9 @@ async function generateMcpCore(params) {
   let totalCount = 0;
   const allPaths = [];
   let hasDiff = false;
-  const toolTargets = (0, import_es_toolkit4.intersection)(
-    config.getTargets(),
-    McpProcessor.getToolTargets({ global: config.getGlobal() })
-  );
+  const supportedMcpTargets = McpProcessor.getToolTargets({ global: config.getGlobal() });
+  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedMcpTargets);
+  warnUnsupportedTargets({ config, supportedTargets: supportedMcpTargets, featureName: "mcp" });
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       if (!config.getFeatures(toolTarget).includes("mcp")) {
@@ -16995,13 +17004,16 @@ async function generateCommandsCore(params) {
   let totalCount = 0;
   const allPaths = [];
   let hasDiff = false;
-  const toolTargets = (0, import_es_toolkit4.intersection)(
-    config.getTargets(),
-    CommandsProcessor.getToolTargets({
-      global: config.getGlobal(),
-      includeSimulated: config.getSimulateCommands()
-    })
-  );
+  const supportedCommandsTargets = CommandsProcessor.getToolTargets({
+    global: config.getGlobal(),
+    includeSimulated: config.getSimulateCommands()
+  });
+  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedCommandsTargets);
+  warnUnsupportedTargets({
+    config,
+    supportedTargets: supportedCommandsTargets,
+    featureName: "commands"
+  });
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       if (!config.getFeatures(toolTarget).includes("commands")) {
@@ -17032,13 +17044,16 @@ async function generateSubagentsCore(params) {
   let totalCount = 0;
   const allPaths = [];
   let hasDiff = false;
-  const toolTargets = (0, import_es_toolkit4.intersection)(
-    config.getTargets(),
-    SubagentsProcessor.getToolTargets({
-      global: config.getGlobal(),
-      includeSimulated: config.getSimulateSubagents()
-    })
-  );
+  const supportedSubagentsTargets = SubagentsProcessor.getToolTargets({
+    global: config.getGlobal(),
+    includeSimulated: config.getSimulateSubagents()
+  });
+  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedSubagentsTargets);
+  warnUnsupportedTargets({
+    config,
+    supportedTargets: supportedSubagentsTargets,
+    featureName: "subagents"
+  });
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       if (!config.getFeatures(toolTarget).includes("subagents")) {
@@ -17070,13 +17085,16 @@ async function generateSkillsCore(params) {
   const allPaths = [];
   let hasDiff = false;
   const allSkills = [];
-  const toolTargets = (0, import_es_toolkit4.intersection)(
-    config.getTargets(),
-    SkillsProcessor.getToolTargets({
-      global: config.getGlobal(),
-      includeSimulated: config.getSimulateSkills()
-    })
-  );
+  const supportedSkillsTargets = SkillsProcessor.getToolTargets({
+    global: config.getGlobal(),
+    includeSimulated: config.getSimulateSkills()
+  });
+  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedSkillsTargets);
+  warnUnsupportedTargets({
+    config,
+    supportedTargets: supportedSkillsTargets,
+    featureName: "skills"
+  });
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       if (!config.getFeatures(toolTarget).includes("skills")) {
@@ -17112,10 +17130,9 @@ async function generateHooksCore(params) {
   let totalCount = 0;
   const allPaths = [];
   let hasDiff = false;
-  const toolTargets = (0, import_es_toolkit4.intersection)(
-    config.getTargets(),
-    HooksProcessor.getToolTargets({ global: config.getGlobal() })
-  );
+  const supportedHooksTargets = HooksProcessor.getToolTargets({ global: config.getGlobal() });
+  const toolTargets = (0, import_es_toolkit4.intersection)(config.getTargets(), supportedHooksTargets);
+  warnUnsupportedTargets({ config, supportedTargets: supportedHooksTargets, featureName: "hooks" });
   for (const baseDir of config.getBaseDirs()) {
     for (const toolTarget of toolTargets) {
       if (!config.getFeatures(toolTarget).includes("hooks")) {
@@ -17291,7 +17308,7 @@ var RULESYNC_HEADER = "# Generated by Rulesync";
 var LEGACY_RULESYNC_HEADER = "# Generated by rulesync - AI tool configuration files";
 var RULESYNC_IGNORE_ENTRIES = [
   // Rulesync curated (fetched) skills
-  ".rulesync/skills/.curated/",
+  `${RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH}/`,
   // AGENTS.md
   "**/AGENTS.md",
   "**/.agents/",
@@ -17511,6 +17528,7 @@ async function importRulesCore(params) {
   });
   const toolFiles = await rulesProcessor.loadToolFiles();
   if (toolFiles.length === 0) {
+    logger.warn(`No rule files found for ${tool}. Skipping import.`);
     return 0;
   }
   const rulesyncFiles = await rulesProcessor.convertToolFilesToRulesyncFiles(toolFiles);
@@ -17538,6 +17556,7 @@ async function importIgnoreCore(params) {
   });
   const toolFiles = await ignoreProcessor.loadToolFiles();
   if (toolFiles.length === 0) {
+    logger.warn(`No ignore files found for ${tool}. Skipping import.`);
     return 0;
   }
   const rulesyncFiles = await ignoreProcessor.convertToolFilesToRulesyncFiles(toolFiles);
@@ -17567,6 +17586,7 @@ async function importMcpCore(params) {
   });
   const toolFiles = await mcpProcessor.loadToolFiles();
   if (toolFiles.length === 0) {
+    logger.warn(`No MCP files found for ${tool}. Skipping import.`);
     return 0;
   }
   const rulesyncFiles = await mcpProcessor.convertToolFilesToRulesyncFiles(toolFiles);
@@ -17593,6 +17613,7 @@ async function importCommandsCore(params) {
   });
   const toolFiles = await commandsProcessor.loadToolFiles();
   if (toolFiles.length === 0) {
+    logger.warn(`No command files found for ${tool}. Skipping import.`);
     return 0;
   }
   const rulesyncFiles = await commandsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
@@ -17619,6 +17640,7 @@ async function importSubagentsCore(params) {
   });
   const toolFiles = await subagentsProcessor.loadToolFiles();
   if (toolFiles.length === 0) {
+    logger.warn(`No subagent files found for ${tool}. Skipping import.`);
     return 0;
   }
   const rulesyncFiles = await subagentsProcessor.convertToolFilesToRulesyncFiles(toolFiles);
@@ -17645,6 +17667,7 @@ async function importSkillsCore(params) {
   });
   const toolDirs = await skillsProcessor.loadToolDirs();
   if (toolDirs.length === 0) {
+    logger.warn(`No skill directories found for ${tool}. Skipping import.`);
     return 0;
   }
   const rulesyncDirs = await skillsProcessor.convertToolDirsToRulesyncDirs(toolDirs);
@@ -17676,6 +17699,7 @@ async function importHooksCore(params) {
   });
   const toolFiles = await hooksProcessor.loadToolFiles();
   if (toolFiles.length === 0) {
+    logger.warn(`No hooks files found for ${tool}. Skipping import.`);
     return 0;
   }
   const rulesyncFiles = await hooksProcessor.convertToolFilesToRulesyncFiles(toolFiles);
@@ -18069,15 +18093,22 @@ function normalizeSourceKey(source) {
     "https://www.github.com/",
     "https://github.com/",
     "http://www.github.com/",
-    "http://github.com/"
+    "http://github.com/",
+    "https://www.gitlab.com/",
+    "https://gitlab.com/",
+    "http://www.gitlab.com/",
+    "http://gitlab.com/"
   ]) {
     if (key.toLowerCase().startsWith(prefix)) {
       key = key.substring(prefix.length);
       break;
     }
   }
-  if (key.startsWith("github:")) {
-    key = key.substring("github:".length);
+  for (const provider of ["github:", "gitlab:"]) {
+    if (key.startsWith(provider)) {
+      key = key.substring(provider.length);
+      break;
+    }
   }
   key = key.replace(/\/+$/, "");
   key = key.replace(/\.git$/, "");
@@ -18161,10 +18192,9 @@ async function resolveAndFetchSources(params) {
         allFetchedSkillNames.add(name);
       }
     } catch (error) {
+      logger.error(`Failed to fetch source "${sourceEntry.source}": ${formatError(error)}`);
       if (error instanceof GitHubClientError) {
         logGitHubAuthHints(error);
-      } else {
-        logger.error(`Failed to fetch source "${sourceEntry.source}": ${formatError(error)}`);
       }
     }
   }
@@ -18199,7 +18229,8 @@ async function fetchSource(params) {
   let { lock } = params;
   const parsed = parseSource(sourceEntry.source);
   if (parsed.provider === "gitlab") {
-    throw new Error("GitLab sources are not yet supported.");
+    logger.warn(`GitLab sources are not yet supported. Skipping "${sourceEntry.source}".`);
+    return { skillCount: 0, fetchedSkillNames: [], updatedLock: lock };
   }
   const sourceKey = sourceEntry.source;
   const locked = getLockedSource(lock, sourceKey);
@@ -20161,7 +20192,7 @@ async function updateCommand(currentVersion, options) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "7.11.0";
+var getVersion = () => "7.12.1";
 var main = async () => {
   const program = new import_commander.Command();
   const version = getVersion();