rulesync 7.11.0 → 7.12.1

package/dist/index.cjs

@@ -759,10 +759,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;
   }
@@ -935,7 +934,7 @@ var ToolCommand = class extends AiFile {
 
 // src/features/commands/simulated-command.ts
 var SimulatedCommandFrontmatterSchema = import_mini4.z.object({
-  description: import_mini4.z.string()
+  description: import_mini4.z.optional(import_mini4.z.string())
 });
 var SimulatedCommand = class _SimulatedCommand extends ToolCommand {
   frontmatter;
@@ -1122,7 +1121,7 @@ var RulesyncFile = class extends AiFile {
 // src/features/commands/rulesync-command.ts
 var RulesyncCommandFrontmatterSchema = import_mini5.z.looseObject({
   targets: import_mini5.z._default(RulesyncTargetsSchema, ["*"]),
-  description: import_mini5.z.string()
+  description: import_mini5.z.optional(import_mini5.z.string())
 });
 var RulesyncCommand = class _RulesyncCommand extends RulesyncFile {
   frontmatter;
@@ -1210,7 +1209,7 @@ var AntigravityWorkflowFrontmatterSchema = import_mini6.z.looseObject({
   turbo: import_mini6.z.optional(import_mini6.z.boolean())
 });
 var AntigravityCommandFrontmatterSchema = import_mini6.z.looseObject({
-  description: import_mini6.z.string(),
+  description: import_mini6.z.optional(import_mini6.z.string()),
   // Support for workflow-specific configuration
   ...AntigravityWorkflowFrontmatterSchema.shape
 });
@@ -1383,7 +1382,7 @@ ${body}${turboDirective}`;
 var import_node_path9 = require("path");
 var import_mini7 = require("zod/mini");
 var ClaudecodeCommandFrontmatterSchema = import_mini7.z.looseObject({
-  description: import_mini7.z.string(),
+  description: import_mini7.z.optional(import_mini7.z.string()),
   "allowed-tools": import_mini7.z.optional(import_mini7.z.union([import_mini7.z.string(), import_mini7.z.array(import_mini7.z.string())])),
   "argument-hint": import_mini7.z.optional(import_mini7.z.string()),
   model: import_mini7.z.optional(import_mini7.z.string()),
@@ -1538,8 +1537,7 @@ var ClineCommand = class _ClineCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: process.cwd(),
@@ -1624,8 +1622,7 @@ var CodexcliCommand = class _CodexcliCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: ".",
@@ -1703,7 +1700,7 @@ var import_node_path12 = require("path");
 var import_mini8 = require("zod/mini");
 var CopilotCommandFrontmatterSchema = import_mini8.z.looseObject({
   mode: import_mini8.z.optional(import_mini8.z.string()),
-  description: import_mini8.z.string()
+  description: import_mini8.z.optional(import_mini8.z.string())
 });
 var CopilotCommand = class _CopilotCommand extends ToolCommand {
   frontmatter;
@@ -1886,7 +1883,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,
@@ -2080,7 +2077,7 @@ var GeminiCliCommand = class _GeminiCliCommand extends ToolCommand {
       }
       return {
         ...result.data,
-        description: result.data.description || ""
+        description: result.data.description
       };
     } catch (error) {
       throw new Error(
@@ -2102,7 +2099,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 }
     };
@@ -2131,8 +2128,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 });
@@ -2202,8 +2200,7 @@ var KiloCommand = class _KiloCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: process.cwd(),
@@ -2283,8 +2280,7 @@ var KiroCommand = class _KiroCommand extends ToolCommand {
   }
   toRulesyncCommand() {
     const rulesyncFrontmatter = {
-      targets: ["*"],
-      description: ""
+      targets: ["*"]
     };
     return new RulesyncCommand({
       baseDir: process.cwd(),
@@ -2358,7 +2354,7 @@ var KiroCommand = class _KiroCommand extends ToolCommand {
 var import_node_path18 = require("path");
 var import_mini11 = require("zod/mini");
 var OpenCodeCommandFrontmatterSchema = import_mini11.z.looseObject({
-  description: import_mini11.z.string(),
+  description: import_mini11.z.optional(import_mini11.z.string()),
   agent: (0, import_mini11.optional)(import_mini11.z.string()),
   subtask: (0, import_mini11.optional)(import_mini11.z.boolean()),
   model: (0, import_mini11.optional)(import_mini11.z.string())
@@ -2498,7 +2494,7 @@ var OpenCodeCommand = class _OpenCodeCommand extends ToolCommand {
 var import_node_path19 = require("path");
 var import_mini12 = require("zod/mini");
 var RooCommandFrontmatterSchema = import_mini12.z.looseObject({
-  description: import_mini12.z.string(),
+  description: import_mini12.z.optional(import_mini12.z.string()),
   "argument-hint": (0, import_mini12.optional)(import_mini12.z.string())
 });
 var RooCommand = class _RooCommand extends ToolCommand {
@@ -3037,7 +3033,7 @@ var HookDefinitionSchema = import_mini14.z.looseObject({
   type: import_mini14.z.optional(import_mini14.z.enum(["command", "prompt"])),
   timeout: import_mini14.z.optional(import_mini14.z.number()),
   matcher: import_mini14.z.optional(safeString),
-  prompt: import_mini14.z.optional(import_mini14.z.string()),
+  prompt: import_mini14.z.optional(safeString),
   loop_limit: import_mini14.z.optional(import_mini14.z.nullable(import_mini14.z.number())),
   name: import_mini14.z.optional(safeString),
   description: import_mini14.z.optional(safeString)
@@ -3089,7 +3085,7 @@ var OPENCODE_HOOK_EVENTS = [
 var COPILOT_HOOK_EVENTS = [
   "sessionStart",
   "sessionEnd",
-  "afterSubmitPrompt",
+  "beforeSubmitPrompt",
   "preToolUse",
   "postToolUse",
   "afterError"
@@ -3200,7 +3196,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"
@@ -3228,6 +3224,104 @@ var GEMINICLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(
 // src/features/hooks/claudecode-hooks.ts
 var import_node_path22 = 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 {
 };
@@ -3318,91 +3412,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({
@@ -3454,7 +3469,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({
@@ -3477,7 +3496,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)
     });
@@ -3786,91 +3808,12 @@ var CursorHooks = class _CursorHooks extends ToolHooks {
 
 // src/features/hooks/factorydroid-hooks.ts
 var import_node_path25 = 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({
@@ -3922,7 +3865,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({
@@ -3945,7 +3892,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)
     });
@@ -8073,7 +8023,8 @@ var RulesyncSkillFrontmatterSchemaInternal = import_mini24.z.looseObject({
   targets: import_mini24.z._default(RulesyncTargetsSchema, ["*"]),
   claudecode: import_mini24.z.optional(
     import_mini24.z.looseObject({
-      "allowed-tools": import_mini24.z.optional(import_mini24.z.array(import_mini24.z.string()))
+      "allowed-tools": import_mini24.z.optional(import_mini24.z.array(import_mini24.z.string())),
+      model: import_mini24.z.optional(import_mini24.z.string())
     })
   ),
   codexcli: import_mini24.z.optional(
@@ -8509,7 +8460,8 @@ var import_mini27 = require("zod/mini");
 var ClaudecodeSkillFrontmatterSchema = import_mini27.z.looseObject({
   name: import_mini27.z.string(),
   description: import_mini27.z.string(),
-  "allowed-tools": import_mini27.z.optional(import_mini27.z.array(import_mini27.z.string()))
+  "allowed-tools": import_mini27.z.optional(import_mini27.z.array(import_mini27.z.string())),
+  model: import_mini27.z.optional(import_mini27.z.string())
 });
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
@@ -8575,15 +8527,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,
@@ -8605,7 +8557,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({
@@ -10735,7 +10692,7 @@ var ToolSubagent = class extends ToolFile {
 // src/features/subagents/simulated-subagent.ts
 var SimulatedSubagentFrontmatterSchema = import_mini39.z.object({
   name: import_mini39.z.string(),
-  description: import_mini39.z.string()
+  description: import_mini39.z.optional(import_mini39.z.string())
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -10959,7 +10916,7 @@ var import_mini40 = require("zod/mini");
 var RulesyncSubagentFrontmatterSchema = import_mini40.z.looseObject({
   targets: import_mini40.z._default(RulesyncTargetsSchema, ["*"]),
   name: import_mini40.z.string(),
-  description: import_mini40.z.string()
+  description: import_mini40.z.optional(import_mini40.z.string())
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -11030,7 +10987,7 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 // src/features/subagents/claudecode-subagent.ts
 var ClaudecodeSubagentFrontmatterSchema = import_mini41.z.looseObject({
   name: import_mini41.z.string(),
-  description: import_mini41.z.string(),
+  description: import_mini41.z.optional(import_mini41.z.string()),
   model: import_mini41.z.optional(import_mini41.z.string()),
   tools: import_mini41.z.optional(import_mini41.z.union([import_mini41.z.string(), import_mini41.z.array(import_mini41.z.string())])),
   permissionMode: import_mini41.z.optional(import_mini41.z.string()),
@@ -11240,7 +11197,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 }
     };
@@ -11353,7 +11310,7 @@ var import_mini43 = require("zod/mini");
 var REQUIRED_TOOL = "agent/runSubagent";
 var CopilotSubagentFrontmatterSchema = import_mini43.z.looseObject({
   name: import_mini43.z.string(),
-  description: import_mini43.z.string(),
+  description: import_mini43.z.optional(import_mini43.z.string()),
   tools: import_mini43.z.optional(import_mini43.z.union([import_mini43.z.string(), import_mini43.z.array(import_mini43.z.string())]))
 });
 var normalizeTools = (tools) => {
@@ -11518,7 +11475,7 @@ var import_node_path86 = require("path");
 var import_mini44 = require("zod/mini");
 var CursorSubagentFrontmatterSchema = import_mini44.z.looseObject({
   name: import_mini44.z.string(),
-  description: import_mini44.z.string()
+  description: import_mini44.z.optional(import_mini44.z.string())
 });
 var CursorSubagent = class _CursorSubagent extends ToolSubagent {
   frontmatter;
@@ -11723,7 +11680,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 }
     };
@@ -11834,7 +11791,7 @@ var KiroSubagent = class _KiroSubagent extends ToolSubagent {
 var import_node_path88 = require("path");
 var import_mini46 = require("zod/mini");
 var OpenCodeSubagentFrontmatterSchema = import_mini46.z.looseObject({
-  description: import_mini46.z.string(),
+  description: import_mini46.z.optional(import_mini46.z.string()),
   mode: import_mini46.z._default(import_mini46.z.string(), "subagent"),
   name: import_mini46.z.optional(import_mini46.z.string())
 });
@@ -12664,7 +12621,7 @@ var globStrategy = {
   },
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: parseGlobsString(frontmatter.globs),
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12676,7 +12633,7 @@ var manualStrategy = {
   }),
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: [],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12688,7 +12645,7 @@ var alwaysOnStrategy = {
   }),
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: ["**/*"],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12701,7 +12658,7 @@ var modelDecisionStrategy = {
   }),
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: [],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12716,7 +12673,7 @@ var unknownStrategy = {
   },
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12738,7 +12695,7 @@ var inferenceStrategy = {
   },
   exportRulesyncData: ({ description, ...frontmatter }) => ({
     globs: frontmatter.globs ? parseGlobsString(frontmatter.globs) : ["**/*"],
-    description: description || "",
+    description,
     antigravity: frontmatter
   })
 };
@@ -12868,7 +12825,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) {
@@ -12938,7 +12894,6 @@ var AugmentcodeLegacyRule = class _AugmentcodeLegacyRule extends ToolRule {
     const rulesyncFrontmatter = {
       root: this.isRoot(),
       targets: ["*"],
-      description: "",
       globs: this.isRoot() ? ["**/*"] : []
     };
     return new RulesyncRule({
@@ -13113,6 +13068,12 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
         relativeDirPath: ".",
         relativeFilePath: "CLAUDE.md"
       },
+      alternativeRoots: [
+        {
+          relativeDirPath: ".claude",
+          relativeFilePath: "CLAUDE.md"
+        }
+      ],
       nonRoot: {
         relativeDirPath: buildToolPath(".claude", "memories", excludeToolDir)
       }
@@ -13122,18 +13083,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_path96.join)(baseDir, paths.root.relativeDirPath, relativePath2)
+        (0, import_node_path96.join)(baseDir, rootDirPath, paths.root.relativeFilePath)
       );
       return new _ClaudecodeLegacyRule({
         baseDir,
-        relativeDirPath: paths.root.relativeDirPath,
+        relativeDirPath: rootDirPath,
         relativeFilePath: paths.root.relativeFilePath,
         fileContent: fileContent2,
         validate,
@@ -13228,6 +13190,12 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
         relativeDirPath: ".",
         relativeFilePath: "CLAUDE.md"
       },
+      alternativeRoots: [
+        {
+          relativeDirPath: ".claude",
+          relativeFilePath: "CLAUDE.md"
+        }
+      ],
       nonRoot: {
         relativeDirPath: buildToolPath(".claude", "rules", excludeToolDir)
       }
@@ -13260,17 +13228,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_path97.join)(baseDir, paths.root.relativeDirPath, paths.root.relativeFilePath)
+        (0, import_node_path97.join)(baseDir, rootDirPath, paths.root.relativeFilePath)
       );
       return new _ClaudecodeRule({
         baseDir,
-        relativeDirPath: paths.root.relativeDirPath,
+        relativeDirPath: rootDirPath,
         relativeFilePath: paths.root.relativeFilePath,
         frontmatter: {},
         body: fileContent2.trim(),
@@ -13282,16 +13252,12 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
       throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
     }
     const relativePath = (0, import_node_path97.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path97.join)(baseDir, relativePath));
-    const { frontmatter, body: content } = parseFrontmatter(
-      fileContent,
-      (0, import_node_path97.join)(baseDir, relativePath)
-    );
+    const filePath = (0, import_node_path97.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_path97.join)(baseDir, relativePath)}: ${formatError(result.error)}`
-      );
+      throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
     }
     return new _ClaudecodeRule({
       baseDir,
@@ -13723,7 +13689,8 @@ var CopilotRule = class _CopilotRule extends ToolRule {
     const isRoot = relativeFilePath === paths.root.relativeFilePath;
     if (isRoot) {
       const relativePath2 = (0, import_node_path100.join)(paths.root.relativeDirPath, paths.root.relativeFilePath);
-      const fileContent2 = await readFileContent((0, import_node_path100.join)(baseDir, relativePath2));
+      const filePath2 = (0, import_node_path100.join)(baseDir, relativePath2);
+      const fileContent2 = await readFileContent(filePath2);
       return new _CopilotRule({
         baseDir,
         relativeDirPath: paths.root.relativeDirPath,
@@ -13738,16 +13705,12 @@ var CopilotRule = class _CopilotRule extends ToolRule {
       throw new Error(`nonRoot path is not set for ${relativeFilePath}`);
     }
     const relativePath = (0, import_node_path100.join)(paths.nonRoot.relativeDirPath, relativeFilePath);
-    const fileContent = await readFileContent((0, import_node_path100.join)(baseDir, relativePath));
-    const { frontmatter, body: content } = parseFrontmatter(
-      fileContent,
-      (0, import_node_path100.join)(baseDir, relativePath)
-    );
+    const filePath = (0, import_node_path100.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_path100.join)(baseDir, relativeFilePath)}: ${formatError(result.error)}`
-      );
+      throw new Error(`Invalid frontmatter in ${filePath}: ${formatError(result.error)}`);
     }
     return new _CopilotRule({
       baseDir,
@@ -15634,35 +15597,62 @@ var RulesProcessor = class extends FeatureProcessor {
       const settablePaths = factory.class.getSettablePaths({
         global: this.global
       });
+      const resolveRelativeDirPath = (filePath) => {
+        const dirName = (0, import_node_path114.dirname)((0, import_node_path114.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_path114.join)(
             this.baseDir,
             settablePaths.root.relativeDirPath ?? ".",
             settablePaths.root.relativeFilePath
-          )
+          ),
+          settablePaths.alternativeRoots,
+          (alt) => (0, import_node_path114.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_path114.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_path114.basename)(filePath),
+              relativeDirPath,
               global: this.global
-            })
-          )
+            });
+          })
         );
       })();
       logger.debug(`Found ${rootToolRules.length} root tool rule files`);
@@ -15676,17 +15666,24 @@ var RulesProcessor = class extends FeatureProcessor {
         if (!settablePaths.root) {
           return [];
         }
-        const localRootFilePaths = await findFilesByGlobs(
-          (0, import_node_path114.join)(this.baseDir, settablePaths.root.relativeDirPath ?? ".", "CLAUDE.local.md")
+        const uniqueLocalRootFilePaths = await findFilesWithFallback(
+          (0, import_node_path114.join)(this.baseDir, settablePaths.root.relativeDirPath ?? ".", "CLAUDE.local.md"),
+          settablePaths.alternativeRoots,
+          (alt) => (0, import_node_path114.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_path114.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 () => {
@@ -15905,6 +15902,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_path115.join)(params.baseDir, RULESYNC_RELATIVE_DIR_PATH));
 }
@@ -15942,10 +15947,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")) {
@@ -15977,13 +15981,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;
     }
@@ -16027,10 +16037,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")) {
@@ -16061,13 +16070,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")) {
@@ -16098,13 +16110,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")) {
@@ -16136,13 +16151,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")) {
@@ -16178,10 +16196,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")) {
@@ -16253,6 +16270,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);
@@ -16280,6 +16298,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);
@@ -16309,6 +16328,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);
@@ -16335,6 +16355,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);
@@ -16361,6 +16382,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);
@@ -16387,6 +16409,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);
@@ -16418,6 +16441,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);