rulesync 8.6.0 → 8.7.0

package/dist/index.cjs

@@ -357,7 +357,13 @@ var SourceEntrySchema = import_mini3.z.object({
       (0, import_mini3.refine)((v) => !(0, import_node_path3.isAbsolute)(v), "path must not be absolute"),
       (0, import_mini3.refine)((v) => !hasControlCharacters(v), "path must not contain control characters")
     )
-  )
+  ),
+  // gh-mode-only fields. Ignored by --mode rulesync. Defaults applied at the
+  // gh install site (`agent` defaults to "github-copilot", `scope` to "project").
+  agent: (0, import_mini3.optional)(
+    import_mini3.z.enum(["github-copilot", "claude-code", "cursor", "codex", "gemini", "antigravity"])
+  ),
+  scope: (0, import_mini3.optional)(import_mini3.z.enum(["project", "user"]))
 });
 var ConfigParamsSchema = import_mini3.z.object({
   baseDirs: import_mini3.z.array(import_mini3.z.string()),
@@ -3607,7 +3613,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 };
 
 // src/features/hooks/hooks-processor.ts
-var import_mini20 = require("zod/mini");
+var import_mini19 = require("zod/mini");
 
 // src/types/hooks.ts
 var import_mini16 = require("zod/mini");
@@ -3911,22 +3917,34 @@ function canonicalToToolHooks({
           `matcher "${matcherKey}" on "${eventName}" hook will be ignored \u2014 this event does not support matchers`
         );
       }
-      const hooks = defs.map((def) => {
+      const hooks = [];
+      for (const def of defs) {
+        const hookType = def.type ?? "command";
+        if (converterConfig.supportedHookTypes && !converterConfig.supportedHookTypes.has(hookType)) {
+          continue;
+        }
         const commandText = def.command;
         const trimmedCommand = typeof commandText === "string" ? commandText.trimStart() : void 0;
-        const shouldPrefix = typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && (!converterConfig.prefixDotRelativeCommandsOnly || trimmedCommand.startsWith("."));
+        const shouldPrefix = converterConfig.projectDirVar !== "" && typeof trimmedCommand === "string" && !trimmedCommand.startsWith("$") && (!converterConfig.prefixDotRelativeCommandsOnly || trimmedCommand.startsWith("."));
         const command = shouldPrefix && typeof trimmedCommand === "string" ? `${converterConfig.projectDirVar}/${trimmedCommand.replace(/^\.\//, "")}` : def.command;
-        return {
-          type: def.type ?? "command",
+        hooks.push({
+          type: hookType,
           ...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 }
-        };
-      });
+          ...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt },
+          ...converterConfig.passthroughFields?.includes("name") && def.name !== void 0 && def.name !== null && { name: def.name },
+          ...converterConfig.passthroughFields?.includes("description") && def.description !== void 0 && def.description !== null && { description: def.description }
+        });
+      }
+      if (hooks.length === 0) {
+        continue;
+      }
       const includeMatcher = matcherKey && !isNoMatcherEvent;
       entries.push(includeMatcher ? { matcher: matcherKey, hooks } : { hooks });
     }
-    result[toolEventName] = entries;
+    if (entries.length > 0) {
+      result[toolEventName] = entries;
+    }
   }
   return result;
 }
@@ -3947,7 +3965,7 @@ function toolHooksToCanonical({
       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(
+        const command = converterConfig.projectDirVar !== "" && typeof cmd === "string" && cmd.includes(`${converterConfig.projectDirVar}/`) ? cmd.replace(
           new RegExp(
             `^${converterConfig.projectDirVar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\/?`
           ),
@@ -3961,6 +3979,8 @@ function toolHooksToCanonical({
           ...command !== void 0 && command !== null && { command },
           ...timeout !== void 0 && timeout !== null && { timeout },
           ...prompt !== void 0 && prompt !== null && { prompt },
+          ...converterConfig.passthroughFields?.includes("name") && typeof h.name === "string" && { name: h.name },
+          ...converterConfig.passthroughFields?.includes("description") && typeof h.description === "string" && { description: h.description },
           ...rawEntry.matcher !== void 0 && rawEntry.matcher !== null && rawEntry.matcher !== "" && { matcher: rawEntry.matcher }
         });
       }
@@ -4059,6 +4079,9 @@ var ToolHooks = class extends ToolFile {
   static forDeletion(_params) {
     throw new Error("Please implement this method in the subclass.");
   }
+  static async getAuxiliaryFiles(_params) {
+    return [];
+  }
 };
 
 // src/features/hooks/claudecode-hooks.ts
@@ -4180,89 +4203,28 @@ var ClaudecodeHooks = class _ClaudecodeHooks extends ToolHooks {
 // src/features/hooks/codexcli-hooks.ts
 var import_node_path26 = require("path");
 var smolToml2 = __toESM(require("smol-toml"), 1);
-var import_mini17 = require("zod/mini");
-function canonicalToCodexcliHooks(config) {
-  const codexSupported = new Set(CODEXCLI_HOOK_EVENTS);
-  const sharedHooks = {};
-  for (const [event, defs] of Object.entries(config.hooks)) {
-    if (codexSupported.has(event)) {
-      sharedHooks[event] = defs;
-    }
-  }
-  const effectiveHooks = {
-    ...sharedHooks,
-    ...config.codexcli?.hooks
-  };
-  const codex = {};
-  for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
-    const codexEventName = CANONICAL_TO_CODEXCLI_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 commandDefs = defs.filter((def) => !def.type || def.type === "command");
-      if (commandDefs.length === 0) continue;
-      const hooks = commandDefs.map((def) => ({
-        type: "command",
-        ...def.command !== void 0 && def.command !== null && { command: def.command },
-        ...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout }
-      }));
-      entries.push(matcherKey ? { matcher: matcherKey, hooks } : { hooks });
-    }
-    if (entries.length > 0) {
-      codex[codexEventName] = entries;
-    }
-  }
-  return codex;
-}
-var CodexHookEntrySchema = import_mini17.z.looseObject({
-  type: import_mini17.z.optional(import_mini17.z.string()),
-  command: import_mini17.z.optional(import_mini17.z.string()),
-  timeout: import_mini17.z.optional(import_mini17.z.number())
-});
-var CodexMatcherEntrySchema = import_mini17.z.looseObject({
-  matcher: import_mini17.z.optional(import_mini17.z.string()),
-  hooks: import_mini17.z.optional(import_mini17.z.array(CodexHookEntrySchema))
-});
-function codexcliHooksToCanonical(codexHooks) {
-  if (codexHooks === null || codexHooks === void 0 || typeof codexHooks !== "object") {
-    return {};
-  }
-  const canonical = {};
-  for (const [codexEventName, matcherEntries] of Object.entries(codexHooks)) {
-    const eventName = CODEXCLI_TO_CANONICAL_EVENT_NAMES[codexEventName] ?? codexEventName;
-    if (!Array.isArray(matcherEntries)) continue;
-    const defs = [];
-    for (const rawEntry of matcherEntries) {
-      const parseResult = CodexMatcherEntrySchema.safeParse(rawEntry);
-      if (!parseResult.success) continue;
-      const entry = parseResult.data;
-      const hooks = entry.hooks ?? [];
-      for (const h of hooks) {
-        const hookType = h.type === "command" || h.type === "prompt" ? h.type : "command";
-        defs.push({
-          type: hookType,
-          ...h.command !== void 0 && h.command !== null && { command: h.command },
-          ...h.timeout !== void 0 && h.timeout !== null && { timeout: h.timeout },
-          ...entry.matcher !== void 0 && entry.matcher !== null && entry.matcher !== "" && { matcher: entry.matcher }
-        });
-      }
-    }
-    if (defs.length > 0) {
-      canonical[eventName] = defs;
-    }
-  }
-  return canonical;
-}
+var CODEXCLI_CONVERTER_CONFIG = {
+  supportedEvents: CODEXCLI_HOOK_EVENTS,
+  canonicalToToolEventNames: CANONICAL_TO_CODEXCLI_EVENT_NAMES,
+  toolToCanonicalEventNames: CODEXCLI_TO_CANONICAL_EVENT_NAMES,
+  projectDirVar: "",
+  supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+  passthroughFields: ["name", "description"]
+};
 async function buildCodexConfigTomlContent({ baseDir }) {
   const configPath = (0, import_node_path26.join)(baseDir, ".codex", "config.toml");
   const existingContent = await readFileContentOrNull(configPath) ?? smolToml2.stringify({});
-  const configToml = smolToml2.parse(existingContent);
+  let configToml;
+  try {
+    configToml = smolToml2.parse(existingContent);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse existing Codex CLI config at ${configPath}: ${formatError(error)}`,
+      {
+        cause: error
+      }
+    );
+  }
   if (typeof configToml.features !== "object" || configToml.features === null) {
     configToml.features = {};
   }
@@ -4317,7 +4279,11 @@ var CodexcliHooks = class _CodexcliHooks extends ToolHooks {
   }) {
     const paths = _CodexcliHooks.getSettablePaths({ global });
     const config = rulesyncHooks.getJson();
-    const codexHooks = canonicalToCodexcliHooks(config);
+    const codexHooks = canonicalToToolHooks({
+      config,
+      toolOverrideHooks: config.codexcli?.hooks,
+      converterConfig: CODEXCLI_CONVERTER_CONFIG
+    });
     const fileContent = JSON.stringify({ hooks: codexHooks }, null, 2);
     return new _CodexcliHooks({
       baseDir,
@@ -4339,7 +4305,10 @@ var CodexcliHooks = class _CodexcliHooks extends ToolHooks {
         }
       );
     }
-    const hooks = codexcliHooksToCanonical(parsed.hooks);
+    const hooks = toolHooksToCanonical({
+      hooks: parsed.hooks,
+      converterConfig: CODEXCLI_CONVERTER_CONFIG
+    });
     return this.toRulesyncHooksDefault({
       fileContent: JSON.stringify({ version: 1, hooks }, null, 2)
     });
@@ -4360,16 +4329,21 @@ var CodexcliHooks = class _CodexcliHooks extends ToolHooks {
       validate: false
     });
   }
+  static async getAuxiliaryFiles({
+    baseDir = process.cwd()
+  } = {}) {
+    return [await CodexcliConfigToml.fromBaseDir({ baseDir })];
+  }
 };
 
 // src/features/hooks/copilot-hooks.ts
 var import_node_path27 = require("path");
-var import_mini18 = require("zod/mini");
-var CopilotHookEntrySchema = import_mini18.z.looseObject({
-  type: import_mini18.z.string(),
-  bash: import_mini18.z.optional(import_mini18.z.string()),
-  powershell: import_mini18.z.optional(import_mini18.z.string()),
-  timeoutSec: import_mini18.z.optional(import_mini18.z.number())
+var import_mini17 = require("zod/mini");
+var CopilotHookEntrySchema = import_mini17.z.looseObject({
+  type: import_mini17.z.string(),
+  bash: import_mini17.z.optional(import_mini17.z.string()),
+  powershell: import_mini17.z.optional(import_mini17.z.string()),
+  timeoutSec: import_mini17.z.optional(import_mini17.z.number())
 });
 function canonicalToCopilotHooks(config) {
   const canonicalSchemaKeys = Object.keys(HookDefinitionSchema.shape);
@@ -4900,7 +4874,7 @@ var FactorydroidHooks = class _FactorydroidHooks extends ToolHooks {
 
 // src/features/hooks/geminicli-hooks.ts
 var import_node_path31 = require("path");
-var import_mini19 = require("zod/mini");
+var import_mini18 = require("zod/mini");
 function canonicalToGeminicliHooks(config) {
   const geminiSupported = new Set(GEMINICLI_HOOK_EVENTS);
   const sharedHooks = {};
@@ -4944,16 +4918,16 @@ function canonicalToGeminicliHooks(config) {
   }
   return gemini;
 }
-var GeminiHookEntrySchema = import_mini19.z.looseObject({
-  type: import_mini19.z.optional(import_mini19.z.string()),
-  command: import_mini19.z.optional(import_mini19.z.string()),
-  timeout: import_mini19.z.optional(import_mini19.z.number()),
-  name: import_mini19.z.optional(import_mini19.z.string()),
-  description: import_mini19.z.optional(import_mini19.z.string())
+var GeminiHookEntrySchema = import_mini18.z.looseObject({
+  type: import_mini18.z.optional(import_mini18.z.string()),
+  command: import_mini18.z.optional(import_mini18.z.string()),
+  timeout: import_mini18.z.optional(import_mini18.z.number()),
+  name: import_mini18.z.optional(import_mini18.z.string()),
+  description: import_mini18.z.optional(import_mini18.z.string())
 });
-var GeminiMatcherEntrySchema = import_mini19.z.looseObject({
-  matcher: import_mini19.z.optional(import_mini19.z.string()),
-  hooks: import_mini19.z.optional(import_mini19.z.array(GeminiHookEntrySchema))
+var GeminiMatcherEntrySchema = import_mini18.z.looseObject({
+  matcher: import_mini18.z.optional(import_mini18.z.string()),
+  hooks: import_mini18.z.optional(import_mini18.z.array(GeminiHookEntrySchema))
 });
 function geminiHooksToCanonical(geminiHooks) {
   if (geminiHooks === null || geminiHooks === void 0 || typeof geminiHooks !== "object") {
@@ -5337,7 +5311,7 @@ var hooksProcessorToolTargetTuple = [
   "geminicli",
   "deepagents"
 ];
-var HooksProcessorToolTargetSchema = import_mini20.z.enum(hooksProcessorToolTargetTuple);
+var HooksProcessorToolTargetSchema = import_mini19.z.enum(hooksProcessorToolTargetTuple);
 var toolHooksFactories = /* @__PURE__ */ new Map([
   [
     "cursor",
@@ -5596,8 +5570,12 @@ var HooksProcessor = class extends FeatureProcessor {
       global: this.global
     });
     const result = [toolHooks];
-    if (this.toolTarget === "codexcli") {
-      result.push(await CodexcliConfigToml.fromBaseDir({ baseDir: this.baseDir }));
+    const auxiliaryFiles = await factory.class.getAuxiliaryFiles?.({
+      baseDir: this.baseDir,
+      global: this.global
+    });
+    if (auxiliaryFiles && auxiliaryFiles.length > 0) {
+      result.push(...auxiliaryFiles);
     }
     return result;
   }
@@ -5617,7 +5595,7 @@ var HooksProcessor = class extends FeatureProcessor {
 };
 
 // src/features/ignore/ignore-processor.ts
-var import_mini22 = require("zod/mini");
+var import_mini21 = require("zod/mini");
 
 // src/features/ignore/augmentcode-ignore.ts
 var import_node_path35 = require("path");
@@ -5796,12 +5774,12 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
 // src/features/ignore/claudecode-ignore.ts
 var import_node_path36 = require("path");
 var import_es_toolkit2 = require("es-toolkit");
-var import_mini21 = require("zod/mini");
+var import_mini20 = require("zod/mini");
 var SHARED_SETTINGS_FILE = "settings.json";
 var LOCAL_SETTINGS_FILE = "settings.local.json";
 var DEFAULT_FILE_MODE = "shared";
-var ClaudecodeIgnoreOptionsSchema = import_mini21.z.looseObject({
-  fileMode: import_mini21.z.optional(import_mini21.z.enum(["shared", "local"]))
+var ClaudecodeIgnoreOptionsSchema = import_mini20.z.looseObject({
+  fileMode: import_mini20.z.optional(import_mini20.z.enum(["shared", "local"]))
 });
 var resolveFileMode = (options) => {
   if (!options) return DEFAULT_FILE_MODE;
@@ -6645,7 +6623,7 @@ var ignoreProcessorToolTargets = [
   "windsurf",
   "zed"
 ];
-var IgnoreProcessorToolTargetSchema = import_mini22.z.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = import_mini21.z.enum(ignoreProcessorToolTargets);
 var toolIgnoreFactories = /* @__PURE__ */ new Map([
   ["augmentcode", { class: AugmentcodeIgnore }],
   ["claudecode", { class: ClaudecodeIgnore }],
@@ -6788,7 +6766,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/features/mcp/mcp-processor.ts
-var import_mini27 = require("zod/mini");
+var import_mini26 = require("zod/mini");
 
 // src/features/mcp/claudecode-mcp.ts
 var import_node_path49 = require("path");
@@ -6796,47 +6774,47 @@ var import_node_path49 = require("path");
 // src/features/mcp/rulesync-mcp.ts
 var import_node_path48 = require("path");
 var import_object = require("es-toolkit/object");
-var import_mini24 = require("zod/mini");
+var import_mini23 = require("zod/mini");
 
 // src/types/mcp.ts
-var import_mini23 = require("zod/mini");
-var McpServerSchema = import_mini23.z.looseObject({
-  type: import_mini23.z.optional(import_mini23.z.enum(["local", "stdio", "sse", "http"])),
-  command: import_mini23.z.optional(import_mini23.z.union([import_mini23.z.string(), import_mini23.z.array(import_mini23.z.string())])),
-  args: import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string())),
-  url: import_mini23.z.optional(import_mini23.z.string()),
-  httpUrl: import_mini23.z.optional(import_mini23.z.string()),
-  env: import_mini23.z.optional(import_mini23.z.record(import_mini23.z.string(), import_mini23.z.string())),
-  disabled: import_mini23.z.optional(import_mini23.z.boolean()),
-  networkTimeout: import_mini23.z.optional(import_mini23.z.number()),
-  timeout: import_mini23.z.optional(import_mini23.z.number()),
-  trust: import_mini23.z.optional(import_mini23.z.boolean()),
-  cwd: import_mini23.z.optional(import_mini23.z.string()),
-  transport: import_mini23.z.optional(import_mini23.z.enum(["local", "stdio", "sse", "http"])),
-  alwaysAllow: import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string())),
-  tools: import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string())),
-  kiroAutoApprove: import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string())),
-  kiroAutoBlock: import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string())),
-  headers: import_mini23.z.optional(import_mini23.z.record(import_mini23.z.string(), import_mini23.z.string())),
-  enabledTools: import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string())),
-  disabledTools: import_mini23.z.optional(import_mini23.z.array(import_mini23.z.string()))
+var import_mini22 = require("zod/mini");
+var McpServerSchema = import_mini22.z.looseObject({
+  type: import_mini22.z.optional(import_mini22.z.enum(["local", "stdio", "sse", "http"])),
+  command: import_mini22.z.optional(import_mini22.z.union([import_mini22.z.string(), import_mini22.z.array(import_mini22.z.string())])),
+  args: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  url: import_mini22.z.optional(import_mini22.z.string()),
+  httpUrl: import_mini22.z.optional(import_mini22.z.string()),
+  env: import_mini22.z.optional(import_mini22.z.record(import_mini22.z.string(), import_mini22.z.string())),
+  disabled: import_mini22.z.optional(import_mini22.z.boolean()),
+  networkTimeout: import_mini22.z.optional(import_mini22.z.number()),
+  timeout: import_mini22.z.optional(import_mini22.z.number()),
+  trust: import_mini22.z.optional(import_mini22.z.boolean()),
+  cwd: import_mini22.z.optional(import_mini22.z.string()),
+  transport: import_mini22.z.optional(import_mini22.z.enum(["local", "stdio", "sse", "http"])),
+  alwaysAllow: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  tools: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  kiroAutoApprove: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  kiroAutoBlock: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  headers: import_mini22.z.optional(import_mini22.z.record(import_mini22.z.string(), import_mini22.z.string())),
+  enabledTools: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string())),
+  disabledTools: import_mini22.z.optional(import_mini22.z.array(import_mini22.z.string()))
 });
-var McpServersSchema = import_mini23.z.record(import_mini23.z.string(), McpServerSchema);
+var McpServersSchema = import_mini22.z.record(import_mini22.z.string(), McpServerSchema);
 function isMcpServers(value) {
   return value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
 // src/features/mcp/rulesync-mcp.ts
-var RulesyncMcpServerSchema = import_mini24.z.extend(McpServerSchema, {
-  targets: import_mini24.z.optional(RulesyncTargetsSchema),
-  description: import_mini24.z.optional(import_mini24.z.string()),
-  exposed: import_mini24.z.optional(import_mini24.z.boolean())
+var RulesyncMcpServerSchema = import_mini23.z.extend(McpServerSchema, {
+  targets: import_mini23.z.optional(RulesyncTargetsSchema),
+  description: import_mini23.z.optional(import_mini23.z.string()),
+  exposed: import_mini23.z.optional(import_mini23.z.boolean())
 });
-var RulesyncMcpConfigSchema = import_mini24.z.object({
-  mcpServers: import_mini24.z.record(import_mini24.z.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = import_mini23.z.object({
+  mcpServers: import_mini23.z.record(import_mini23.z.string(), RulesyncMcpServerSchema)
 });
-var RulesyncMcpFileSchema = import_mini24.z.looseObject({
-  $schema: import_mini24.z.optional(import_mini24.z.string()),
+var RulesyncMcpFileSchema = import_mini23.z.looseObject({
+  $schema: import_mini23.z.optional(import_mini23.z.string()),
   ...RulesyncMcpConfigSchema.shape
 });
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
@@ -8039,25 +8017,25 @@ var JunieMcp = class _JunieMcp extends ToolMcp {
 // src/features/mcp/kilo-mcp.ts
 var import_node_path59 = require("path");
 var import_jsonc_parser3 = require("jsonc-parser");
-var import_mini25 = require("zod/mini");
-var KiloMcpLocalServerSchema = import_mini25.z.object({
-  type: import_mini25.z.literal("local"),
-  command: import_mini25.z.array(import_mini25.z.string()),
-  environment: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.string())),
-  enabled: import_mini25.z._default(import_mini25.z.boolean(), true),
-  cwd: import_mini25.z.optional(import_mini25.z.string())
+var import_mini24 = require("zod/mini");
+var KiloMcpLocalServerSchema = import_mini24.z.object({
+  type: import_mini24.z.literal("local"),
+  command: import_mini24.z.array(import_mini24.z.string()),
+  environment: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.string())),
+  enabled: import_mini24.z._default(import_mini24.z.boolean(), true),
+  cwd: import_mini24.z.optional(import_mini24.z.string())
 });
-var KiloMcpRemoteServerSchema = import_mini25.z.object({
-  type: import_mini25.z.literal("remote"),
-  url: import_mini25.z.string(),
-  headers: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.string())),
-  enabled: import_mini25.z._default(import_mini25.z.boolean(), true)
+var KiloMcpRemoteServerSchema = import_mini24.z.object({
+  type: import_mini24.z.literal("remote"),
+  url: import_mini24.z.string(),
+  headers: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.string())),
+  enabled: import_mini24.z._default(import_mini24.z.boolean(), true)
 });
-var KiloMcpServerSchema = import_mini25.z.union([KiloMcpLocalServerSchema, KiloMcpRemoteServerSchema]);
-var KiloConfigSchema = import_mini25.z.looseObject({
-  $schema: import_mini25.z.optional(import_mini25.z.string()),
-  mcp: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), KiloMcpServerSchema)),
-  tools: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.boolean()))
+var KiloMcpServerSchema = import_mini24.z.union([KiloMcpLocalServerSchema, KiloMcpRemoteServerSchema]);
+var KiloConfigSchema = import_mini24.z.looseObject({
+  $schema: import_mini24.z.optional(import_mini24.z.string()),
+  mcp: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), KiloMcpServerSchema)),
+  tools: import_mini24.z.optional(import_mini24.z.record(import_mini24.z.string(), import_mini24.z.boolean()))
 });
 function convertFromKiloFormat(kiloMcp, tools) {
   return Object.fromEntries(
@@ -8354,28 +8332,28 @@ var KiroMcp = class _KiroMcp extends ToolMcp {
 // src/features/mcp/opencode-mcp.ts
 var import_node_path61 = require("path");
 var import_jsonc_parser4 = require("jsonc-parser");
-var import_mini26 = require("zod/mini");
-var OpencodeMcpLocalServerSchema = import_mini26.z.object({
-  type: import_mini26.z.literal("local"),
-  command: import_mini26.z.array(import_mini26.z.string()),
-  environment: import_mini26.z.optional(import_mini26.z.record(import_mini26.z.string(), import_mini26.z.string())),
-  enabled: import_mini26.z._default(import_mini26.z.boolean(), true),
-  cwd: import_mini26.z.optional(import_mini26.z.string())
+var import_mini25 = require("zod/mini");
+var OpencodeMcpLocalServerSchema = import_mini25.z.object({
+  type: import_mini25.z.literal("local"),
+  command: import_mini25.z.array(import_mini25.z.string()),
+  environment: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.string())),
+  enabled: import_mini25.z._default(import_mini25.z.boolean(), true),
+  cwd: import_mini25.z.optional(import_mini25.z.string())
 });
-var OpencodeMcpRemoteServerSchema = import_mini26.z.object({
-  type: import_mini26.z.literal("remote"),
-  url: import_mini26.z.string(),
-  headers: import_mini26.z.optional(import_mini26.z.record(import_mini26.z.string(), import_mini26.z.string())),
-  enabled: import_mini26.z._default(import_mini26.z.boolean(), true)
+var OpencodeMcpRemoteServerSchema = import_mini25.z.object({
+  type: import_mini25.z.literal("remote"),
+  url: import_mini25.z.string(),
+  headers: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.string())),
+  enabled: import_mini25.z._default(import_mini25.z.boolean(), true)
 });
-var OpencodeMcpServerSchema = import_mini26.z.union([
+var OpencodeMcpServerSchema = import_mini25.z.union([
   OpencodeMcpLocalServerSchema,
   OpencodeMcpRemoteServerSchema
 ]);
-var OpencodeConfigSchema = import_mini26.z.looseObject({
-  $schema: import_mini26.z.optional(import_mini26.z.string()),
-  mcp: import_mini26.z.optional(import_mini26.z.record(import_mini26.z.string(), OpencodeMcpServerSchema)),
-  tools: import_mini26.z.optional(import_mini26.z.record(import_mini26.z.string(), import_mini26.z.boolean()))
+var OpencodeConfigSchema = import_mini25.z.looseObject({
+  $schema: import_mini25.z.optional(import_mini25.z.string()),
+  mcp: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), OpencodeMcpServerSchema)),
+  tools: import_mini25.z.optional(import_mini25.z.record(import_mini25.z.string(), import_mini25.z.boolean()))
 });
 function convertFromOpencodeFormat(opencodeMcp, tools) {
   return Object.fromEntries(
@@ -8846,7 +8824,7 @@ var mcpProcessorToolTargetTuple = [
   "roo",
   "rovodev"
 ];
-var McpProcessorToolTargetSchema = import_mini27.z.enum(mcpProcessorToolTargetTuple);
+var McpProcessorToolTargetSchema = import_mini26.z.enum(mcpProcessorToolTargetTuple);
 var toolMcpFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -9185,7 +9163,7 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/features/permissions/permissions-processor.ts
-var import_mini32 = require("zod/mini");
+var import_mini31 = require("zod/mini");
 
 // src/features/permissions/claudecode-permissions.ts
 var import_node_path65 = require("path");
@@ -9195,14 +9173,14 @@ var import_es_toolkit4 = require("es-toolkit");
 var import_node_path64 = require("path");
 
 // src/types/permissions.ts
-var import_mini28 = require("zod/mini");
-var PermissionActionSchema = import_mini28.z.enum(["allow", "ask", "deny"]);
-var PermissionRulesSchema = import_mini28.z.record(import_mini28.z.string(), PermissionActionSchema);
-var PermissionsConfigSchema = import_mini28.z.looseObject({
-  permission: import_mini28.z.record(import_mini28.z.string(), PermissionRulesSchema)
+var import_mini27 = require("zod/mini");
+var PermissionActionSchema = import_mini27.z.enum(["allow", "ask", "deny"]);
+var PermissionRulesSchema = import_mini27.z.record(import_mini27.z.string(), PermissionActionSchema);
+var PermissionsConfigSchema = import_mini27.z.looseObject({
+  permission: import_mini27.z.record(import_mini27.z.string(), PermissionRulesSchema)
 });
-var RulesyncPermissionsFileSchema = import_mini28.z.looseObject({
-  $schema: import_mini28.z.optional(import_mini28.z.string()),
+var RulesyncPermissionsFileSchema = import_mini27.z.looseObject({
+  $schema: import_mini27.z.optional(import_mini27.z.string()),
   ...PermissionsConfigSchema.shape
 });
 
@@ -9772,7 +9750,7 @@ function mapBashActionToDecision(action) {
 // src/features/permissions/geminicli-permissions.ts
 var import_node_path67 = require("path");
 var smolToml5 = __toESM(require("smol-toml"), 1);
-var import_mini29 = require("zod/mini");
+var import_mini28 = require("zod/mini");
 
 // src/utils/logger.ts
 var BaseLogger = class {
@@ -10168,14 +10146,14 @@ function regexToGlobPattern(regex) {
   }
   return glob;
 }
-var GeminicliPolicyRuleSchema = import_mini29.z.looseObject({
-  toolName: import_mini29.z.string(),
-  decision: import_mini29.z.optional(import_mini29.z.unknown()),
-  commandPrefix: import_mini29.z.optional(import_mini29.z.string()),
-  argsPattern: import_mini29.z.optional(import_mini29.z.string())
+var GeminicliPolicyRuleSchema = import_mini28.z.looseObject({
+  toolName: import_mini28.z.string(),
+  decision: import_mini28.z.optional(import_mini28.z.unknown()),
+  commandPrefix: import_mini28.z.optional(import_mini28.z.string()),
+  argsPattern: import_mini28.z.optional(import_mini28.z.string())
 });
-var GeminicliPolicyFileSchema = import_mini29.z.looseObject({
-  rule: import_mini29.z.optional(import_mini29.z.array(import_mini29.z.looseObject({})))
+var GeminicliPolicyFileSchema = import_mini28.z.looseObject({
+  rule: import_mini28.z.optional(import_mini28.z.array(import_mini28.z.looseObject({})))
 });
 function extractRules(parsed, logger) {
   const parsedFile = GeminicliPolicyFileSchema.safeParse(parsed);
@@ -10211,12 +10189,12 @@ function extractPattern(rule) {
 
 // src/features/permissions/kiro-permissions.ts
 var import_node_path68 = require("path");
-var import_mini30 = require("zod/mini");
-var KiroAgentSchema = import_mini30.z.looseObject({
-  allowedTools: import_mini30.z.optional(import_mini30.z.array(import_mini30.z.string())),
-  toolsSettings: import_mini30.z.optional(import_mini30.z.record(import_mini30.z.string(), import_mini30.z.unknown()))
+var import_mini29 = require("zod/mini");
+var KiroAgentSchema = import_mini29.z.looseObject({
+  allowedTools: import_mini29.z.optional(import_mini29.z.array(import_mini29.z.string())),
+  toolsSettings: import_mini29.z.optional(import_mini29.z.record(import_mini29.z.string(), import_mini29.z.unknown()))
 });
-var UnknownRecordSchema = import_mini30.z.record(import_mini30.z.string(), import_mini30.z.unknown());
+var UnknownRecordSchema = import_mini29.z.record(import_mini29.z.string(), import_mini29.z.unknown());
 var KiroPermissions = class _KiroPermissions extends ToolPermissions {
   static getSettablePaths(_options = {}) {
     return {
@@ -10369,8 +10347,12 @@ function buildKiroPermissionsFromRulesync({
           );
           continue;
         }
-        if (action === "allow")
-          nextAllowedTools.add(category === "webfetch" ? "web_fetch" : "web_search");
+        const toolName = category === "webfetch" ? "web_fetch" : "web_search";
+        if (action === "allow") {
+          nextAllowedTools.add(toolName);
+        } else {
+          nextAllowedTools.delete(toolName);
+        }
       } else {
         logger?.warn(`Kiro permissions do not support category: ${category}. Skipping.`);
       }
@@ -10396,13 +10378,13 @@ function asStringArray(value) {
 // src/features/permissions/opencode-permissions.ts
 var import_node_path69 = require("path");
 var import_jsonc_parser5 = require("jsonc-parser");
-var import_mini31 = require("zod/mini");
-var OpencodePermissionSchema = import_mini31.z.union([
-  import_mini31.z.enum(["allow", "ask", "deny"]),
-  import_mini31.z.record(import_mini31.z.string(), import_mini31.z.enum(["allow", "ask", "deny"]))
+var import_mini30 = require("zod/mini");
+var OpencodePermissionSchema = import_mini30.z.union([
+  import_mini30.z.enum(["allow", "ask", "deny"]),
+  import_mini30.z.record(import_mini30.z.string(), import_mini30.z.enum(["allow", "ask", "deny"]))
 ]);
-var OpencodePermissionsConfigSchema = import_mini31.z.looseObject({
-  permission: import_mini31.z.optional(import_mini31.z.record(import_mini31.z.string(), OpencodePermissionSchema))
+var OpencodePermissionsConfigSchema = import_mini30.z.looseObject({
+  permission: import_mini30.z.optional(import_mini30.z.record(import_mini30.z.string(), OpencodePermissionSchema))
 });
 var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   json;
@@ -10533,7 +10515,7 @@ var permissionsProcessorToolTargetTuple = [
   "kiro",
   "opencode"
 ];
-var PermissionsProcessorToolTargetSchema = import_mini32.z.enum(permissionsProcessorToolTargetTuple);
+var PermissionsProcessorToolTargetSchema = import_mini31.z.enum(permissionsProcessorToolTargetTuple);
 var toolPermissionsFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -10698,7 +10680,7 @@ var PermissionsProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 var import_node_path140 = require("path");
 var import_toon = require("@toon-format/toon");
-var import_mini72 = require("zod/mini");
+var import_mini71 = require("zod/mini");
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -10708,7 +10690,7 @@ var import_node_path73 = require("path");
 
 // src/features/skills/simulated-skill.ts
 var import_node_path72 = require("path");
-var import_mini33 = require("zod/mini");
+var import_mini32 = require("zod/mini");
 
 // src/features/skills/tool-skill.ts
 var import_node_path71 = require("path");
@@ -10945,9 +10927,9 @@ var ToolSkill = class extends AiDir {
 };
 
 // src/features/skills/simulated-skill.ts
-var SimulatedSkillFrontmatterSchema = import_mini33.z.looseObject({
-  name: import_mini33.z.string(),
-  description: import_mini33.z.string()
+var SimulatedSkillFrontmatterSchema = import_mini32.z.looseObject({
+  name: import_mini32.z.string(),
+  description: import_mini32.z.string()
 });
 var SimulatedSkill = class extends ToolSkill {
   frontmatter;
@@ -11174,49 +11156,49 @@ var FactorydroidSkill = class _FactorydroidSkill extends SimulatedSkill {
 
 // src/features/skills/rovodev-skill.ts
 var import_node_path76 = require("path");
-var import_mini35 = require("zod/mini");
+var import_mini34 = require("zod/mini");
 
 // src/features/skills/rulesync-skill.ts
 var import_node_path75 = require("path");
-var import_mini34 = require("zod/mini");
-var RulesyncSkillFrontmatterSchemaInternal = import_mini34.z.looseObject({
-  name: import_mini34.z.string(),
-  description: import_mini34.z.string(),
-  targets: import_mini34.z._default(RulesyncTargetsSchema, ["*"]),
-  claudecode: import_mini34.z.optional(
-    import_mini34.z.looseObject({
-      "allowed-tools": import_mini34.z.optional(import_mini34.z.array(import_mini34.z.string())),
-      model: import_mini34.z.optional(import_mini34.z.string()),
-      "disable-model-invocation": import_mini34.z.optional(import_mini34.z.boolean())
+var import_mini33 = require("zod/mini");
+var RulesyncSkillFrontmatterSchemaInternal = import_mini33.z.looseObject({
+  name: import_mini33.z.string(),
+  description: import_mini33.z.string(),
+  targets: import_mini33.z._default(RulesyncTargetsSchema, ["*"]),
+  claudecode: import_mini33.z.optional(
+    import_mini33.z.looseObject({
+      "allowed-tools": import_mini33.z.optional(import_mini33.z.array(import_mini33.z.string())),
+      model: import_mini33.z.optional(import_mini33.z.string()),
+      "disable-model-invocation": import_mini33.z.optional(import_mini33.z.boolean())
     })
   ),
-  codexcli: import_mini34.z.optional(
-    import_mini34.z.looseObject({
-      "short-description": import_mini34.z.optional(import_mini34.z.string())
+  codexcli: import_mini33.z.optional(
+    import_mini33.z.looseObject({
+      "short-description": import_mini33.z.optional(import_mini33.z.string())
     })
   ),
-  opencode: import_mini34.z.optional(
-    import_mini34.z.looseObject({
-      "allowed-tools": import_mini34.z.optional(import_mini34.z.array(import_mini34.z.string()))
+  opencode: import_mini33.z.optional(
+    import_mini33.z.looseObject({
+      "allowed-tools": import_mini33.z.optional(import_mini33.z.array(import_mini33.z.string()))
     })
   ),
-  kilo: import_mini34.z.optional(
-    import_mini34.z.looseObject({
-      "allowed-tools": import_mini34.z.optional(import_mini34.z.array(import_mini34.z.string()))
+  kilo: import_mini33.z.optional(
+    import_mini33.z.looseObject({
+      "allowed-tools": import_mini33.z.optional(import_mini33.z.array(import_mini33.z.string()))
     })
   ),
-  deepagents: import_mini34.z.optional(
-    import_mini34.z.looseObject({
-      "allowed-tools": import_mini34.z.optional(import_mini34.z.array(import_mini34.z.string()))
+  deepagents: import_mini33.z.optional(
+    import_mini33.z.looseObject({
+      "allowed-tools": import_mini33.z.optional(import_mini33.z.array(import_mini33.z.string()))
     })
   ),
-  copilot: import_mini34.z.optional(
-    import_mini34.z.looseObject({
-      license: import_mini34.z.optional(import_mini34.z.string())
+  copilot: import_mini33.z.optional(
+    import_mini33.z.looseObject({
+      license: import_mini33.z.optional(import_mini33.z.string())
     })
   ),
-  cline: import_mini34.z.optional(import_mini34.z.looseObject({})),
-  roo: import_mini34.z.optional(import_mini34.z.looseObject({}))
+  cline: import_mini33.z.optional(import_mini33.z.looseObject({})),
+  roo: import_mini33.z.optional(import_mini33.z.looseObject({}))
 });
 var RulesyncSkillFrontmatterSchema = RulesyncSkillFrontmatterSchemaInternal;
 var RulesyncSkill = class _RulesyncSkill extends AiDir {
@@ -11313,9 +11295,9 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
 };
 
 // src/features/skills/rovodev-skill.ts
-var RovodevSkillFrontmatterSchema = import_mini35.z.looseObject({
-  name: import_mini35.z.string(),
-  description: import_mini35.z.string()
+var RovodevSkillFrontmatterSchema = import_mini34.z.looseObject({
+  name: import_mini34.z.string(),
+  description: import_mini34.z.string()
 });
 var RovodevSkill = class _RovodevSkill extends ToolSkill {
   constructor({
@@ -11487,7 +11469,7 @@ var RovodevSkill = class _RovodevSkill extends ToolSkill {
 
 // src/features/skills/skills-processor.ts
 var import_node_path95 = require("path");
-var import_mini52 = require("zod/mini");
+var import_mini51 = require("zod/mini");
 
 // src/types/dir-feature-processor.ts
 var import_node_path77 = require("path");
@@ -11626,10 +11608,10 @@ var DirFeatureProcessor = class {
 
 // src/features/skills/agentsskills-skill.ts
 var import_node_path78 = require("path");
-var import_mini36 = require("zod/mini");
-var AgentsSkillsSkillFrontmatterSchema = import_mini36.z.looseObject({
-  name: import_mini36.z.string(),
-  description: import_mini36.z.string()
+var import_mini35 = require("zod/mini");
+var AgentsSkillsSkillFrontmatterSchema = import_mini35.z.looseObject({
+  name: import_mini35.z.string(),
+  description: import_mini35.z.string()
 });
 var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
   constructor({
@@ -11784,10 +11766,10 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
 
 // src/features/skills/antigravity-skill.ts
 var import_node_path79 = require("path");
-var import_mini37 = require("zod/mini");
-var AntigravitySkillFrontmatterSchema = import_mini37.z.looseObject({
-  name: import_mini37.z.string(),
-  description: import_mini37.z.string()
+var import_mini36 = require("zod/mini");
+var AntigravitySkillFrontmatterSchema = import_mini36.z.looseObject({
+  name: import_mini36.z.string(),
+  description: import_mini36.z.string()
 });
 var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
   constructor({
@@ -11945,13 +11927,13 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
 
 // src/features/skills/claudecode-skill.ts
 var import_node_path80 = require("path");
-var import_mini38 = require("zod/mini");
-var ClaudecodeSkillFrontmatterSchema = import_mini38.z.looseObject({
-  name: import_mini38.z.string(),
-  description: import_mini38.z.string(),
-  "allowed-tools": import_mini38.z.optional(import_mini38.z.array(import_mini38.z.string())),
-  model: import_mini38.z.optional(import_mini38.z.string()),
-  "disable-model-invocation": import_mini38.z.optional(import_mini38.z.boolean())
+var import_mini37 = require("zod/mini");
+var ClaudecodeSkillFrontmatterSchema = import_mini37.z.looseObject({
+  name: import_mini37.z.string(),
+  description: import_mini37.z.string(),
+  "allowed-tools": import_mini37.z.optional(import_mini37.z.array(import_mini37.z.string())),
+  model: import_mini37.z.optional(import_mini37.z.string()),
+  "disable-model-invocation": import_mini37.z.optional(import_mini37.z.boolean())
 });
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
@@ -12121,10 +12103,10 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
 
 // src/features/skills/cline-skill.ts
 var import_node_path81 = require("path");
-var import_mini39 = require("zod/mini");
-var ClineSkillFrontmatterSchema = import_mini39.z.looseObject({
-  name: import_mini39.z.string(),
-  description: import_mini39.z.string()
+var import_mini38 = require("zod/mini");
+var ClineSkillFrontmatterSchema = import_mini38.z.looseObject({
+  name: import_mini38.z.string(),
+  description: import_mini38.z.string()
 });
 var ClineSkill = class _ClineSkill extends ToolSkill {
   constructor({
@@ -12294,13 +12276,13 @@ var ClineSkill = class _ClineSkill extends ToolSkill {
 
 // src/features/skills/codexcli-skill.ts
 var import_node_path82 = require("path");
-var import_mini40 = require("zod/mini");
-var CodexCliSkillFrontmatterSchema = import_mini40.z.looseObject({
-  name: import_mini40.z.string(),
-  description: import_mini40.z.string(),
-  metadata: import_mini40.z.optional(
-    import_mini40.z.looseObject({
-      "short-description": import_mini40.z.optional(import_mini40.z.string())
+var import_mini39 = require("zod/mini");
+var CodexCliSkillFrontmatterSchema = import_mini39.z.looseObject({
+  name: import_mini39.z.string(),
+  description: import_mini39.z.string(),
+  metadata: import_mini39.z.optional(
+    import_mini39.z.looseObject({
+      "short-description": import_mini39.z.optional(import_mini39.z.string())
     })
   )
 });
@@ -12465,11 +12447,11 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
 
 // src/features/skills/copilot-skill.ts
 var import_node_path83 = require("path");
-var import_mini41 = require("zod/mini");
-var CopilotSkillFrontmatterSchema = import_mini41.z.looseObject({
-  name: import_mini41.z.string(),
-  description: import_mini41.z.string(),
-  license: import_mini41.z.optional(import_mini41.z.string())
+var import_mini40 = require("zod/mini");
+var CopilotSkillFrontmatterSchema = import_mini40.z.looseObject({
+  name: import_mini40.z.string(),
+  description: import_mini40.z.string(),
+  license: import_mini40.z.optional(import_mini40.z.string())
 });
 var CopilotSkill = class _CopilotSkill extends ToolSkill {
   constructor({
@@ -12630,10 +12612,10 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
 
 // src/features/skills/cursor-skill.ts
 var import_node_path84 = require("path");
-var import_mini42 = require("zod/mini");
-var CursorSkillFrontmatterSchema = import_mini42.z.looseObject({
-  name: import_mini42.z.string(),
-  description: import_mini42.z.string()
+var import_mini41 = require("zod/mini");
+var CursorSkillFrontmatterSchema = import_mini41.z.looseObject({
+  name: import_mini41.z.string(),
+  description: import_mini41.z.string()
 });
 var CursorSkill = class _CursorSkill extends ToolSkill {
   constructor({
@@ -12785,11 +12767,11 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
 
 // src/features/skills/deepagents-skill.ts
 var import_node_path85 = require("path");
-var import_mini43 = require("zod/mini");
-var DeepagentsSkillFrontmatterSchema = import_mini43.z.looseObject({
-  name: import_mini43.z.string(),
-  description: import_mini43.z.string(),
-  "allowed-tools": import_mini43.z.optional(import_mini43.z.array(import_mini43.z.string()))
+var import_mini42 = require("zod/mini");
+var DeepagentsSkillFrontmatterSchema = import_mini42.z.looseObject({
+  name: import_mini42.z.string(),
+  description: import_mini42.z.string(),
+  "allowed-tools": import_mini42.z.optional(import_mini42.z.array(import_mini42.z.string()))
 });
 var DeepagentsSkill = class _DeepagentsSkill extends ToolSkill {
   constructor({
@@ -12947,10 +12929,10 @@ var DeepagentsSkill = class _DeepagentsSkill extends ToolSkill {
 
 // src/features/skills/geminicli-skill.ts
 var import_node_path86 = require("path");
-var import_mini44 = require("zod/mini");
-var GeminiCliSkillFrontmatterSchema = import_mini44.z.looseObject({
-  name: import_mini44.z.string(),
-  description: import_mini44.z.string()
+var import_mini43 = require("zod/mini");
+var GeminiCliSkillFrontmatterSchema = import_mini43.z.looseObject({
+  name: import_mini43.z.string(),
+  description: import_mini43.z.string()
 });
 var GeminiCliSkill = class _GeminiCliSkill extends ToolSkill {
   constructor({
@@ -13104,10 +13086,10 @@ var GeminiCliSkill = class _GeminiCliSkill extends ToolSkill {
 
 // src/features/skills/junie-skill.ts
 var import_node_path87 = require("path");
-var import_mini45 = require("zod/mini");
-var JunieSkillFrontmatterSchema = import_mini45.z.looseObject({
-  name: import_mini45.z.string(),
-  description: import_mini45.z.string()
+var import_mini44 = require("zod/mini");
+var JunieSkillFrontmatterSchema = import_mini44.z.looseObject({
+  name: import_mini44.z.string(),
+  description: import_mini44.z.string()
 });
 var JunieSkill = class _JunieSkill extends ToolSkill {
   constructor({
@@ -13280,11 +13262,11 @@ var JunieSkill = class _JunieSkill extends ToolSkill {
 
 // src/features/skills/kilo-skill.ts
 var import_node_path88 = require("path");
-var import_mini46 = require("zod/mini");
-var KiloSkillFrontmatterSchema = import_mini46.z.looseObject({
-  name: import_mini46.z.string(),
-  description: import_mini46.z.string(),
-  "allowed-tools": import_mini46.z.optional(import_mini46.z.array(import_mini46.z.string()))
+var import_mini45 = require("zod/mini");
+var KiloSkillFrontmatterSchema = import_mini45.z.looseObject({
+  name: import_mini45.z.string(),
+  description: import_mini45.z.string(),
+  "allowed-tools": import_mini45.z.optional(import_mini45.z.array(import_mini45.z.string()))
 });
 var KiloSkill = class _KiloSkill extends ToolSkill {
   constructor({
@@ -13441,10 +13423,10 @@ var KiloSkill = class _KiloSkill extends ToolSkill {
 
 // src/features/skills/kiro-skill.ts
 var import_node_path89 = require("path");
-var import_mini47 = require("zod/mini");
-var KiroSkillFrontmatterSchema = import_mini47.z.looseObject({
-  name: import_mini47.z.string(),
-  description: import_mini47.z.string()
+var import_mini46 = require("zod/mini");
+var KiroSkillFrontmatterSchema = import_mini46.z.looseObject({
+  name: import_mini46.z.string(),
+  description: import_mini46.z.string()
 });
 var KiroSkill = class _KiroSkill extends ToolSkill {
   constructor({
@@ -13618,11 +13600,11 @@ var KiroSkill = class _KiroSkill extends ToolSkill {
 
 // src/features/skills/opencode-skill.ts
 var import_node_path90 = require("path");
-var import_mini48 = require("zod/mini");
-var OpenCodeSkillFrontmatterSchema = import_mini48.z.looseObject({
-  name: import_mini48.z.string(),
-  description: import_mini48.z.string(),
-  "allowed-tools": import_mini48.z.optional(import_mini48.z.array(import_mini48.z.string()))
+var import_mini47 = require("zod/mini");
+var OpenCodeSkillFrontmatterSchema = import_mini47.z.looseObject({
+  name: import_mini47.z.string(),
+  description: import_mini47.z.string(),
+  "allowed-tools": import_mini47.z.optional(import_mini47.z.array(import_mini47.z.string()))
 });
 var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
   constructor({
@@ -13779,10 +13761,10 @@ var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
 
 // src/features/skills/replit-skill.ts
 var import_node_path91 = require("path");
-var import_mini49 = require("zod/mini");
-var ReplitSkillFrontmatterSchema = import_mini49.z.looseObject({
-  name: import_mini49.z.string(),
-  description: import_mini49.z.string()
+var import_mini48 = require("zod/mini");
+var ReplitSkillFrontmatterSchema = import_mini48.z.looseObject({
+  name: import_mini48.z.string(),
+  description: import_mini48.z.string()
 });
 var ReplitSkill = class _ReplitSkill extends ToolSkill {
   constructor({
@@ -13937,10 +13919,10 @@ var ReplitSkill = class _ReplitSkill extends ToolSkill {
 
 // src/features/skills/roo-skill.ts
 var import_node_path92 = require("path");
-var import_mini50 = require("zod/mini");
-var RooSkillFrontmatterSchema = import_mini50.z.looseObject({
-  name: import_mini50.z.string(),
-  description: import_mini50.z.string()
+var import_mini49 = require("zod/mini");
+var RooSkillFrontmatterSchema = import_mini49.z.looseObject({
+  name: import_mini49.z.string(),
+  description: import_mini49.z.string()
 });
 var RooSkill = class _RooSkill extends ToolSkill {
   constructor({
@@ -14129,10 +14111,10 @@ async function getLocalSkillDirNames(baseDir) {
 
 // src/features/skills/windsurf-skill.ts
 var import_node_path94 = require("path");
-var import_mini51 = require("zod/mini");
-var WindsurfSkillFrontmatterSchema = import_mini51.z.looseObject({
-  name: import_mini51.z.string(),
-  description: import_mini51.z.string()
+var import_mini50 = require("zod/mini");
+var WindsurfSkillFrontmatterSchema = import_mini50.z.looseObject({
+  name: import_mini50.z.string(),
+  description: import_mini50.z.string()
 });
 var WindsurfSkill = class _WindsurfSkill extends ToolSkill {
   constructor({
@@ -14310,7 +14292,7 @@ var skillsProcessorToolTargetTuple = [
   "rovodev",
   "windsurf"
 ];
-var SkillsProcessorToolTargetSchema = import_mini52.z.enum(skillsProcessorToolTargetTuple);
+var SkillsProcessorToolTargetSchema = import_mini51.z.enum(skillsProcessorToolTargetTuple);
 var toolSkillFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -14689,7 +14671,7 @@ var import_node_path97 = require("path");
 
 // src/features/subagents/simulated-subagent.ts
 var import_node_path96 = require("path");
-var import_mini53 = require("zod/mini");
+var import_mini52 = require("zod/mini");
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -14741,9 +14723,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = import_mini53.z.object({
-  name: import_mini53.z.string(),
-  description: import_mini53.z.optional(import_mini53.z.string())
+var SimulatedSubagentFrontmatterSchema = import_mini52.z.object({
+  name: import_mini52.z.string(),
+  description: import_mini52.z.optional(import_mini52.z.string())
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -14901,15 +14883,15 @@ var FactorydroidSubagent = class _FactorydroidSubagent extends SimulatedSubagent
 
 // src/features/subagents/geminicli-subagent.ts
 var import_node_path100 = require("path");
-var import_mini55 = require("zod/mini");
+var import_mini54 = require("zod/mini");
 
 // src/features/subagents/rulesync-subagent.ts
 var import_node_path99 = require("path");
-var import_mini54 = require("zod/mini");
-var RulesyncSubagentFrontmatterSchema = import_mini54.z.looseObject({
-  targets: import_mini54.z._default(RulesyncTargetsSchema, ["*"]),
-  name: import_mini54.z.string(),
-  description: import_mini54.z.optional(import_mini54.z.string())
+var import_mini53 = require("zod/mini");
+var RulesyncSubagentFrontmatterSchema = import_mini53.z.looseObject({
+  targets: import_mini53.z._default(RulesyncTargetsSchema, ["*"]),
+  name: import_mini53.z.string(),
+  description: import_mini53.z.optional(import_mini53.z.string())
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -14978,9 +14960,9 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/geminicli-subagent.ts
-var GeminiCliSubagentFrontmatterSchema = import_mini55.z.looseObject({
-  name: import_mini55.z.string(),
-  description: import_mini55.z.optional(import_mini55.z.string())
+var GeminiCliSubagentFrontmatterSchema = import_mini54.z.looseObject({
+  name: import_mini54.z.string(),
+  description: import_mini54.z.optional(import_mini54.z.string())
 });
 var GeminiCliSubagent = class _GeminiCliSubagent extends ToolSubagent {
   frontmatter;
@@ -15153,10 +15135,10 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/rovodev-subagent.ts
 var import_node_path102 = require("path");
-var import_mini56 = require("zod/mini");
-var RovodevSubagentFrontmatterSchema = import_mini56.z.looseObject({
-  name: import_mini56.z.string(),
-  description: import_mini56.z.optional(import_mini56.z.string())
+var import_mini55 = require("zod/mini");
+var RovodevSubagentFrontmatterSchema = import_mini55.z.looseObject({
+  name: import_mini55.z.string(),
+  description: import_mini55.z.optional(import_mini55.z.string())
 });
 var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
   frontmatter;
@@ -15298,18 +15280,18 @@ var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
 
 // src/features/subagents/subagents-processor.ts
 var import_node_path113 = require("path");
-var import_mini65 = require("zod/mini");
+var import_mini64 = require("zod/mini");
 
 // src/features/subagents/claudecode-subagent.ts
 var import_node_path103 = require("path");
-var import_mini57 = require("zod/mini");
-var ClaudecodeSubagentFrontmatterSchema = import_mini57.z.looseObject({
-  name: import_mini57.z.string(),
-  description: import_mini57.z.optional(import_mini57.z.string()),
-  model: import_mini57.z.optional(import_mini57.z.string()),
-  tools: import_mini57.z.optional(import_mini57.z.union([import_mini57.z.string(), import_mini57.z.array(import_mini57.z.string())])),
-  permissionMode: import_mini57.z.optional(import_mini57.z.string()),
-  skills: import_mini57.z.optional(import_mini57.z.union([import_mini57.z.string(), import_mini57.z.array(import_mini57.z.string())]))
+var import_mini56 = require("zod/mini");
+var ClaudecodeSubagentFrontmatterSchema = import_mini56.z.looseObject({
+  name: import_mini56.z.string(),
+  description: import_mini56.z.optional(import_mini56.z.string()),
+  model: import_mini56.z.optional(import_mini56.z.string()),
+  tools: import_mini56.z.optional(import_mini56.z.union([import_mini56.z.string(), import_mini56.z.array(import_mini56.z.string())])),
+  permissionMode: import_mini56.z.optional(import_mini56.z.string()),
+  skills: import_mini56.z.optional(import_mini56.z.union([import_mini56.z.string(), import_mini56.z.array(import_mini56.z.string())]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -15465,14 +15447,14 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 // src/features/subagents/codexcli-subagent.ts
 var import_node_path104 = require("path");
 var smolToml6 = __toESM(require("smol-toml"), 1);
-var import_mini58 = require("zod/mini");
-var CodexCliSubagentTomlSchema = import_mini58.z.looseObject({
-  name: import_mini58.z.string(),
-  description: import_mini58.z.optional(import_mini58.z.string()),
-  developer_instructions: import_mini58.z.optional(import_mini58.z.string()),
-  model: import_mini58.z.optional(import_mini58.z.string()),
-  model_reasoning_effort: import_mini58.z.optional(import_mini58.z.string()),
-  sandbox_mode: import_mini58.z.optional(import_mini58.z.string())
+var import_mini57 = require("zod/mini");
+var CodexCliSubagentTomlSchema = import_mini57.z.looseObject({
+  name: import_mini57.z.string(),
+  description: import_mini57.z.optional(import_mini57.z.string()),
+  developer_instructions: import_mini57.z.optional(import_mini57.z.string()),
+  model: import_mini57.z.optional(import_mini57.z.string()),
+  model_reasoning_effort: import_mini57.z.optional(import_mini57.z.string()),
+  sandbox_mode: import_mini57.z.optional(import_mini57.z.string())
 });
 function stringifyCodexCliSubagentToml(tomlObj) {
   const { developer_instructions, ...restFields } = tomlObj;
@@ -15638,12 +15620,12 @@ var CodexCliSubagent = class _CodexCliSubagent extends ToolSubagent {
 
 // src/features/subagents/copilot-subagent.ts
 var import_node_path105 = require("path");
-var import_mini59 = require("zod/mini");
+var import_mini58 = require("zod/mini");
 var REQUIRED_TOOL = "agent/runSubagent";
-var CopilotSubagentFrontmatterSchema = import_mini59.z.looseObject({
-  name: import_mini59.z.string(),
-  description: import_mini59.z.optional(import_mini59.z.string()),
-  tools: import_mini59.z.optional(import_mini59.z.union([import_mini59.z.string(), import_mini59.z.array(import_mini59.z.string())]))
+var CopilotSubagentFrontmatterSchema = import_mini58.z.looseObject({
+  name: import_mini58.z.string(),
+  description: import_mini58.z.optional(import_mini58.z.string()),
+  tools: import_mini58.z.optional(import_mini58.z.union([import_mini58.z.string(), import_mini58.z.array(import_mini58.z.string())]))
 });
 var normalizeTools = (tools) => {
   if (!tools) {
@@ -15655,6 +15637,21 @@ var ensureRequiredTool = (tools) => {
   const mergedTools = /* @__PURE__ */ new Set([REQUIRED_TOOL, ...tools]);
   return Array.from(mergedTools);
 };
+var toCopilotAgentFilePath = (relativeFilePath) => {
+  if (relativeFilePath.endsWith(".agent.md")) {
+    return relativeFilePath;
+  }
+  if (relativeFilePath.endsWith(".md")) {
+    return relativeFilePath.replace(/\.md$/, ".agent.md");
+  }
+  return relativeFilePath;
+};
+var toRulesyncFilePath = (relativeFilePath) => {
+  if (relativeFilePath.endsWith(".agent.md")) {
+    return relativeFilePath.replace(/\.agent\.md$/, ".md");
+  }
+  return relativeFilePath;
+};
 var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
   frontmatter;
   body;
@@ -15701,7 +15698,7 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
       frontmatter: rulesyncFrontmatter,
       body: this.body,
       relativeDirPath: RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
-      relativeFilePath: this.getRelativeFilePath(),
+      relativeFilePath: toRulesyncFilePath(this.getRelativeFilePath()),
       validate: true
     });
   }
@@ -15727,16 +15724,12 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
     const body = rulesyncSubagent.getBody();
     const fileContent = stringifyFrontmatter(body, copilotFrontmatter);
     const paths = this.getSettablePaths({ global });
-    let relativeFilePath = rulesyncSubagent.getRelativeFilePath();
-    if (!relativeFilePath.endsWith(".agent.md")) {
-      relativeFilePath = relativeFilePath.replace(/\.md$/, ".agent.md");
-    }
     return new _CopilotSubagent({
       baseDir,
       frontmatter: copilotFrontmatter,
       body,
       relativeDirPath: paths.relativeDirPath,
-      relativeFilePath,
+      relativeFilePath: toCopilotAgentFilePath(rulesyncSubagent.getRelativeFilePath()),
       fileContent,
       validate,
       global
@@ -15808,10 +15801,10 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
 
 // src/features/subagents/cursor-subagent.ts
 var import_node_path106 = require("path");
-var import_mini60 = require("zod/mini");
-var CursorSubagentFrontmatterSchema = import_mini60.z.looseObject({
-  name: import_mini60.z.string(),
-  description: import_mini60.z.optional(import_mini60.z.string())
+var import_mini59 = require("zod/mini");
+var CursorSubagentFrontmatterSchema = import_mini59.z.looseObject({
+  name: import_mini59.z.string(),
+  description: import_mini59.z.optional(import_mini59.z.string())
 });
 var CursorSubagent = class _CursorSubagent extends ToolSubagent {
   frontmatter;
@@ -15955,11 +15948,11 @@ var CursorSubagent = class _CursorSubagent extends ToolSubagent {
 
 // src/features/subagents/deepagents-subagent.ts
 var import_node_path107 = require("path");
-var import_mini61 = require("zod/mini");
-var DeepagentsSubagentFrontmatterSchema = import_mini61.z.looseObject({
-  name: import_mini61.z.string(),
-  description: import_mini61.z.optional(import_mini61.z.string()),
-  model: import_mini61.z.optional(import_mini61.z.string())
+var import_mini60 = require("zod/mini");
+var DeepagentsSubagentFrontmatterSchema = import_mini60.z.looseObject({
+  name: import_mini60.z.string(),
+  description: import_mini60.z.optional(import_mini60.z.string()),
+  model: import_mini60.z.optional(import_mini60.z.string())
 });
 var DeepagentsSubagent = class _DeepagentsSubagent extends ToolSubagent {
   frontmatter;
@@ -16108,10 +16101,10 @@ var DeepagentsSubagent = class _DeepagentsSubagent extends ToolSubagent {
 
 // src/features/subagents/junie-subagent.ts
 var import_node_path108 = require("path");
-var import_mini62 = require("zod/mini");
-var JunieSubagentFrontmatterSchema = import_mini62.z.looseObject({
-  name: import_mini62.z.optional(import_mini62.z.string()),
-  description: import_mini62.z.string()
+var import_mini61 = require("zod/mini");
+var JunieSubagentFrontmatterSchema = import_mini61.z.looseObject({
+  name: import_mini61.z.optional(import_mini61.z.string()),
+  description: import_mini61.z.string()
 });
 var JunieSubagent = class _JunieSubagent extends ToolSubagent {
   frontmatter;
@@ -16269,11 +16262,11 @@ var import_node_path110 = require("path");
 
 // src/features/subagents/opencode-style-subagent.ts
 var import_node_path109 = require("path");
-var import_mini63 = require("zod/mini");
-var OpenCodeStyleSubagentFrontmatterSchema = import_mini63.z.looseObject({
-  description: import_mini63.z.optional(import_mini63.z.string()),
-  mode: import_mini63.z._default(import_mini63.z.string(), "subagent"),
-  name: import_mini63.z.optional(import_mini63.z.string())
+var import_mini62 = require("zod/mini");
+var OpenCodeStyleSubagentFrontmatterSchema = import_mini62.z.looseObject({
+  description: import_mini62.z.optional(import_mini62.z.string()),
+  mode: import_mini62.z._default(import_mini62.z.string(), "subagent"),
+  name: import_mini62.z.optional(import_mini62.z.string())
 });
 var OpenCodeStyleSubagent = class extends ToolSubagent {
   frontmatter;
@@ -16422,22 +16415,22 @@ var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
 
 // src/features/subagents/kiro-subagent.ts
 var import_node_path111 = require("path");
-var import_mini64 = require("zod/mini");
-var KiroCliSubagentJsonSchema = import_mini64.z.looseObject({
-  name: import_mini64.z.string(),
-  description: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.string())),
-  prompt: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.string())),
-  tools: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.array(import_mini64.z.string()))),
-  toolAliases: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.record(import_mini64.z.string(), import_mini64.z.string()))),
-  toolSettings: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.unknown())),
-  toolSchema: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.unknown())),
-  hooks: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.record(import_mini64.z.string(), import_mini64.z.array(import_mini64.z.unknown())))),
-  model: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.string())),
-  mcpServers: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.record(import_mini64.z.string(), import_mini64.z.unknown()))),
-  useLegacyMcpJson: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.boolean())),
-  resources: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.array(import_mini64.z.string()))),
-  allowedTools: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.array(import_mini64.z.string()))),
-  includeMcpJson: import_mini64.z.optional(import_mini64.z.nullable(import_mini64.z.boolean()))
+var import_mini63 = require("zod/mini");
+var KiroCliSubagentJsonSchema = import_mini63.z.looseObject({
+  name: import_mini63.z.string(),
+  description: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.string())),
+  prompt: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.string())),
+  tools: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.array(import_mini63.z.string()))),
+  toolAliases: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.record(import_mini63.z.string(), import_mini63.z.string()))),
+  toolSettings: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.unknown())),
+  toolSchema: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.unknown())),
+  hooks: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.record(import_mini63.z.string(), import_mini63.z.array(import_mini63.z.unknown())))),
+  model: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.string())),
+  mcpServers: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.record(import_mini63.z.string(), import_mini63.z.unknown()))),
+  useLegacyMcpJson: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.boolean())),
+  resources: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.array(import_mini63.z.string()))),
+  allowedTools: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.array(import_mini63.z.string()))),
+  includeMcpJson: import_mini63.z.optional(import_mini63.z.nullable(import_mini63.z.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -16698,7 +16691,7 @@ var subagentsProcessorToolTargetTuple = [
   "roo",
   "rovodev"
 ];
-var SubagentsProcessorToolTargetSchema = import_mini65.z.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = import_mini64.z.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -17008,42 +17001,42 @@ var import_node_path115 = require("path");
 
 // src/features/rules/rulesync-rule.ts
 var import_node_path114 = require("path");
-var import_mini66 = require("zod/mini");
-var RulesyncRuleFrontmatterSchema = import_mini66.z.object({
-  root: import_mini66.z.optional(import_mini66.z.boolean()),
-  localRoot: import_mini66.z.optional(import_mini66.z.boolean()),
-  targets: import_mini66.z._default(RulesyncTargetsSchema, ["*"]),
-  description: import_mini66.z.optional(import_mini66.z.string()),
-  globs: import_mini66.z.optional(import_mini66.z.array(import_mini66.z.string())),
-  agentsmd: import_mini66.z.optional(
-    import_mini66.z.looseObject({
+var import_mini65 = require("zod/mini");
+var RulesyncRuleFrontmatterSchema = import_mini65.z.object({
+  root: import_mini65.z.optional(import_mini65.z.boolean()),
+  localRoot: import_mini65.z.optional(import_mini65.z.boolean()),
+  targets: import_mini65.z._default(RulesyncTargetsSchema, ["*"]),
+  description: import_mini65.z.optional(import_mini65.z.string()),
+  globs: import_mini65.z.optional(import_mini65.z.array(import_mini65.z.string())),
+  agentsmd: import_mini65.z.optional(
+    import_mini65.z.looseObject({
       // @example "path/to/subproject"
-      subprojectPath: import_mini66.z.optional(import_mini66.z.string())
+      subprojectPath: import_mini65.z.optional(import_mini65.z.string())
     })
   ),
-  claudecode: import_mini66.z.optional(
-    import_mini66.z.looseObject({
+  claudecode: import_mini65.z.optional(
+    import_mini65.z.looseObject({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example ["src/**/*.ts", "tests/**/*.test.ts"]
-      paths: import_mini66.z.optional(import_mini66.z.array(import_mini66.z.string()))
+      paths: import_mini65.z.optional(import_mini65.z.array(import_mini65.z.string()))
     })
   ),
-  cursor: import_mini66.z.optional(
-    import_mini66.z.looseObject({
-      alwaysApply: import_mini66.z.optional(import_mini66.z.boolean()),
-      description: import_mini66.z.optional(import_mini66.z.string()),
-      globs: import_mini66.z.optional(import_mini66.z.array(import_mini66.z.string()))
+  cursor: import_mini65.z.optional(
+    import_mini65.z.looseObject({
+      alwaysApply: import_mini65.z.optional(import_mini65.z.boolean()),
+      description: import_mini65.z.optional(import_mini65.z.string()),
+      globs: import_mini65.z.optional(import_mini65.z.array(import_mini65.z.string()))
     })
   ),
-  copilot: import_mini66.z.optional(
-    import_mini66.z.looseObject({
-      excludeAgent: import_mini66.z.optional(import_mini66.z.union([import_mini66.z.literal("code-review"), import_mini66.z.literal("coding-agent")]))
+  copilot: import_mini65.z.optional(
+    import_mini65.z.looseObject({
+      excludeAgent: import_mini65.z.optional(import_mini65.z.union([import_mini65.z.literal("code-review"), import_mini65.z.literal("coding-agent")]))
     })
   ),
-  antigravity: import_mini66.z.optional(
-    import_mini66.z.looseObject({
-      trigger: import_mini66.z.optional(import_mini66.z.string()),
-      globs: import_mini66.z.optional(import_mini66.z.array(import_mini66.z.string()))
+  antigravity: import_mini65.z.optional(
+    import_mini65.z.looseObject({
+      trigger: import_mini65.z.optional(import_mini65.z.string()),
+      globs: import_mini65.z.optional(import_mini65.z.array(import_mini65.z.string()))
     })
   )
 });
@@ -17343,20 +17336,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 var import_node_path117 = require("path");
-var import_mini67 = require("zod/mini");
-var AntigravityRuleFrontmatterSchema = import_mini67.z.looseObject({
-  trigger: import_mini67.z.optional(
-    import_mini67.z.union([
-      import_mini67.z.literal("always_on"),
-      import_mini67.z.literal("glob"),
-      import_mini67.z.literal("manual"),
-      import_mini67.z.literal("model_decision"),
-      import_mini67.z.string()
+var import_mini66 = require("zod/mini");
+var AntigravityRuleFrontmatterSchema = import_mini66.z.looseObject({
+  trigger: import_mini66.z.optional(
+    import_mini66.z.union([
+      import_mini66.z.literal("always_on"),
+      import_mini66.z.literal("glob"),
+      import_mini66.z.literal("manual"),
+      import_mini66.z.literal("model_decision"),
+      import_mini66.z.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: import_mini67.z.optional(import_mini67.z.string()),
-  description: import_mini67.z.optional(import_mini67.z.string())
+  globs: import_mini66.z.optional(import_mini66.z.string()),
+  description: import_mini66.z.optional(import_mini66.z.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -17943,9 +17936,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 var import_node_path121 = require("path");
-var import_mini68 = require("zod/mini");
-var ClaudecodeRuleFrontmatterSchema = import_mini68.z.object({
-  paths: import_mini68.z.optional(import_mini68.z.array(import_mini68.z.string()))
+var import_mini67 = require("zod/mini");
+var ClaudecodeRuleFrontmatterSchema = import_mini67.z.object({
+  paths: import_mini67.z.optional(import_mini67.z.array(import_mini67.z.string()))
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -18161,9 +18154,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 var import_node_path122 = require("path");
-var import_mini69 = require("zod/mini");
-var ClineRuleFrontmatterSchema = import_mini69.z.object({
-  description: import_mini69.z.string()
+var import_mini68 = require("zod/mini");
+var ClineRuleFrontmatterSchema = import_mini68.z.object({
+  description: import_mini68.z.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths(_options = {}) {
@@ -18342,11 +18335,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 var import_node_path124 = require("path");
-var import_mini70 = require("zod/mini");
-var CopilotRuleFrontmatterSchema = import_mini70.z.object({
-  description: import_mini70.z.optional(import_mini70.z.string()),
-  applyTo: import_mini70.z.optional(import_mini70.z.string()),
-  excludeAgent: import_mini70.z.optional(import_mini70.z.union([import_mini70.z.literal("code-review"), import_mini70.z.literal("coding-agent")]))
+var import_mini69 = require("zod/mini");
+var CopilotRuleFrontmatterSchema = import_mini69.z.object({
+  description: import_mini69.z.optional(import_mini69.z.string()),
+  applyTo: import_mini69.z.optional(import_mini69.z.string()),
+  excludeAgent: import_mini69.z.optional(import_mini69.z.union([import_mini69.z.literal("code-review"), import_mini69.z.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -18588,11 +18581,11 @@ var CopilotcliRule = class _CopilotcliRule extends CopilotRule {
 
 // src/features/rules/cursor-rule.ts
 var import_node_path125 = require("path");
-var import_mini71 = require("zod/mini");
-var CursorRuleFrontmatterSchema = import_mini71.z.object({
-  description: import_mini71.z.optional(import_mini71.z.string()),
-  globs: import_mini71.z.optional(import_mini71.z.string()),
-  alwaysApply: import_mini71.z.optional(import_mini71.z.boolean())
+var import_mini70 = require("zod/mini");
+var CursorRuleFrontmatterSchema = import_mini70.z.object({
+  description: import_mini70.z.optional(import_mini70.z.string()),
+  globs: import_mini70.z.optional(import_mini70.z.string()),
+  alwaysApply: import_mini70.z.optional(import_mini70.z.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -20252,11 +20245,11 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = import_mini72.z.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = import_mini71.z.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => (0, import_node_path140.join)(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
-var RulesFeatureOptionsSchema = import_mini72.z.looseObject({
-  ruleDiscoveryMode: import_mini72.z.optional(import_mini72.z.enum(["none", "explicit"])),
-  includeLocalRoot: import_mini72.z.optional(import_mini72.z.boolean())
+var RulesFeatureOptionsSchema = import_mini71.z.looseObject({
+  ruleDiscoveryMode: import_mini71.z.optional(import_mini71.z.enum(["none", "explicit"])),
+  includeLocalRoot: import_mini71.z.optional(import_mini71.z.boolean())
 });
 var resolveRuleDiscoveryMode = ({
   defaultMode,
@@ -20277,8 +20270,8 @@ var resolveRuleDiscoveryMode = ({
   }
   return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
 };
-var IncludeLocalRootSchema = import_mini72.z.looseObject({
-  includeLocalRoot: import_mini72.z.optional(import_mini72.z.boolean())
+var IncludeLocalRootSchema = import_mini71.z.looseObject({
+  includeLocalRoot: import_mini71.z.optional(import_mini71.z.boolean())
 });
 var resolveIncludeLocalRoot = (options) => {
   if (!options) return true;