rulesync 8.6.0 → 8.7.0

package/dist/{chunk-ILMHM7BF.js → chunk-QGQQJNZD.js}

@@ -349,7 +349,13 @@ var SourceEntrySchema = z3.object({
       refine((v) => !isAbsolute(v), "path must not be absolute"),
       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: optional(
+    z3.enum(["github-copilot", "claude-code", "cursor", "codex", "gemini", "antigravity"])
+  ),
+  scope: optional(z3.enum(["project", "user"]))
 });
 var ConfigParamsSchema = z3.object({
   baseDirs: z3.array(z3.string()),
@@ -3769,7 +3775,7 @@ var CommandsProcessor = class extends FeatureProcessor {
 };
 
 // src/features/hooks/hooks-processor.ts
-import { z as z20 } from "zod/mini";
+import { z as z19 } from "zod/mini";
 
 // src/types/hooks.ts
 import { z as z16 } from "zod/mini";
@@ -4073,22 +4079,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;
 }
@@ -4109,7 +4127,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, "\\$&")}\\/?`
           ),
@@ -4123,6 +4141,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 }
         });
       }
@@ -4221,6 +4241,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
@@ -4342,89 +4365,28 @@ var ClaudecodeHooks = class _ClaudecodeHooks extends ToolHooks {
 // src/features/hooks/codexcli-hooks.ts
 import { join as join23 } from "path";
 import * as smolToml2 from "smol-toml";
-import { z as z17 } from "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 = z17.looseObject({
-  type: z17.optional(z17.string()),
-  command: z17.optional(z17.string()),
-  timeout: z17.optional(z17.number())
-});
-var CodexMatcherEntrySchema = z17.looseObject({
-  matcher: z17.optional(z17.string()),
-  hooks: z17.optional(z17.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 = join23(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 = {};
   }
@@ -4479,7 +4441,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,
@@ -4501,7 +4467,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)
     });
@@ -4522,16 +4491,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
 import { join as join24 } from "path";
-import { z as z18 } from "zod/mini";
-var CopilotHookEntrySchema = z18.looseObject({
-  type: z18.string(),
-  bash: z18.optional(z18.string()),
-  powershell: z18.optional(z18.string()),
-  timeoutSec: z18.optional(z18.number())
+import { z as z17 } from "zod/mini";
+var CopilotHookEntrySchema = z17.looseObject({
+  type: z17.string(),
+  bash: z17.optional(z17.string()),
+  powershell: z17.optional(z17.string()),
+  timeoutSec: z17.optional(z17.number())
 });
 function canonicalToCopilotHooks(config) {
   const canonicalSchemaKeys = Object.keys(HookDefinitionSchema.shape);
@@ -5062,7 +5036,7 @@ var FactorydroidHooks = class _FactorydroidHooks extends ToolHooks {
 
 // src/features/hooks/geminicli-hooks.ts
 import { join as join28 } from "path";
-import { z as z19 } from "zod/mini";
+import { z as z18 } from "zod/mini";
 function canonicalToGeminicliHooks(config) {
   const geminiSupported = new Set(GEMINICLI_HOOK_EVENTS);
   const sharedHooks = {};
@@ -5106,16 +5080,16 @@ function canonicalToGeminicliHooks(config) {
   }
   return gemini;
 }
-var GeminiHookEntrySchema = z19.looseObject({
-  type: z19.optional(z19.string()),
-  command: z19.optional(z19.string()),
-  timeout: z19.optional(z19.number()),
-  name: z19.optional(z19.string()),
-  description: z19.optional(z19.string())
+var GeminiHookEntrySchema = z18.looseObject({
+  type: z18.optional(z18.string()),
+  command: z18.optional(z18.string()),
+  timeout: z18.optional(z18.number()),
+  name: z18.optional(z18.string()),
+  description: z18.optional(z18.string())
 });
-var GeminiMatcherEntrySchema = z19.looseObject({
-  matcher: z19.optional(z19.string()),
-  hooks: z19.optional(z19.array(GeminiHookEntrySchema))
+var GeminiMatcherEntrySchema = z18.looseObject({
+  matcher: z18.optional(z18.string()),
+  hooks: z18.optional(z18.array(GeminiHookEntrySchema))
 });
 function geminiHooksToCanonical(geminiHooks) {
   if (geminiHooks === null || geminiHooks === void 0 || typeof geminiHooks !== "object") {
@@ -5499,7 +5473,7 @@ var hooksProcessorToolTargetTuple = [
   "geminicli",
   "deepagents"
 ];
-var HooksProcessorToolTargetSchema = z20.enum(hooksProcessorToolTargetTuple);
+var HooksProcessorToolTargetSchema = z19.enum(hooksProcessorToolTargetTuple);
 var toolHooksFactories = /* @__PURE__ */ new Map([
   [
     "cursor",
@@ -5758,8 +5732,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;
   }
@@ -5779,7 +5757,7 @@ var HooksProcessor = class extends FeatureProcessor {
 };
 
 // src/features/ignore/ignore-processor.ts
-import { z as z22 } from "zod/mini";
+import { z as z21 } from "zod/mini";
 
 // src/features/ignore/augmentcode-ignore.ts
 import { join as join32 } from "path";
@@ -5958,12 +5936,12 @@ var AugmentcodeIgnore = class _AugmentcodeIgnore extends ToolIgnore {
 // src/features/ignore/claudecode-ignore.ts
 import { join as join33 } from "path";
 import { uniq } from "es-toolkit";
-import { z as z21 } from "zod/mini";
+import { z as z20 } from "zod/mini";
 var SHARED_SETTINGS_FILE = "settings.json";
 var LOCAL_SETTINGS_FILE = "settings.local.json";
 var DEFAULT_FILE_MODE = "shared";
-var ClaudecodeIgnoreOptionsSchema = z21.looseObject({
-  fileMode: z21.optional(z21.enum(["shared", "local"]))
+var ClaudecodeIgnoreOptionsSchema = z20.looseObject({
+  fileMode: z20.optional(z20.enum(["shared", "local"]))
 });
 var resolveFileMode = (options) => {
   if (!options) return DEFAULT_FILE_MODE;
@@ -6807,7 +6785,7 @@ var ignoreProcessorToolTargets = [
   "windsurf",
   "zed"
 ];
-var IgnoreProcessorToolTargetSchema = z22.enum(ignoreProcessorToolTargets);
+var IgnoreProcessorToolTargetSchema = z21.enum(ignoreProcessorToolTargets);
 var toolIgnoreFactories = /* @__PURE__ */ new Map([
   ["augmentcode", { class: AugmentcodeIgnore }],
   ["claudecode", { class: ClaudecodeIgnore }],
@@ -6950,7 +6928,7 @@ var IgnoreProcessor = class extends FeatureProcessor {
 };
 
 // src/features/mcp/mcp-processor.ts
-import { z as z27 } from "zod/mini";
+import { z as z26 } from "zod/mini";
 
 // src/features/mcp/claudecode-mcp.ts
 import { join as join46 } from "path";
@@ -6958,47 +6936,47 @@ import { join as join46 } from "path";
 // src/features/mcp/rulesync-mcp.ts
 import { join as join45 } from "path";
 import { omit } from "es-toolkit/object";
-import { z as z24 } from "zod/mini";
+import { z as z23 } from "zod/mini";
 
 // src/types/mcp.ts
-import { z as z23 } from "zod/mini";
-var McpServerSchema = z23.looseObject({
-  type: z23.optional(z23.enum(["local", "stdio", "sse", "http"])),
-  command: z23.optional(z23.union([z23.string(), z23.array(z23.string())])),
-  args: z23.optional(z23.array(z23.string())),
-  url: z23.optional(z23.string()),
-  httpUrl: z23.optional(z23.string()),
-  env: z23.optional(z23.record(z23.string(), z23.string())),
-  disabled: z23.optional(z23.boolean()),
-  networkTimeout: z23.optional(z23.number()),
-  timeout: z23.optional(z23.number()),
-  trust: z23.optional(z23.boolean()),
-  cwd: z23.optional(z23.string()),
-  transport: z23.optional(z23.enum(["local", "stdio", "sse", "http"])),
-  alwaysAllow: z23.optional(z23.array(z23.string())),
-  tools: z23.optional(z23.array(z23.string())),
-  kiroAutoApprove: z23.optional(z23.array(z23.string())),
-  kiroAutoBlock: z23.optional(z23.array(z23.string())),
-  headers: z23.optional(z23.record(z23.string(), z23.string())),
-  enabledTools: z23.optional(z23.array(z23.string())),
-  disabledTools: z23.optional(z23.array(z23.string()))
+import { z as z22 } from "zod/mini";
+var McpServerSchema = z22.looseObject({
+  type: z22.optional(z22.enum(["local", "stdio", "sse", "http"])),
+  command: z22.optional(z22.union([z22.string(), z22.array(z22.string())])),
+  args: z22.optional(z22.array(z22.string())),
+  url: z22.optional(z22.string()),
+  httpUrl: z22.optional(z22.string()),
+  env: z22.optional(z22.record(z22.string(), z22.string())),
+  disabled: z22.optional(z22.boolean()),
+  networkTimeout: z22.optional(z22.number()),
+  timeout: z22.optional(z22.number()),
+  trust: z22.optional(z22.boolean()),
+  cwd: z22.optional(z22.string()),
+  transport: z22.optional(z22.enum(["local", "stdio", "sse", "http"])),
+  alwaysAllow: z22.optional(z22.array(z22.string())),
+  tools: z22.optional(z22.array(z22.string())),
+  kiroAutoApprove: z22.optional(z22.array(z22.string())),
+  kiroAutoBlock: z22.optional(z22.array(z22.string())),
+  headers: z22.optional(z22.record(z22.string(), z22.string())),
+  enabledTools: z22.optional(z22.array(z22.string())),
+  disabledTools: z22.optional(z22.array(z22.string()))
 });
-var McpServersSchema = z23.record(z23.string(), McpServerSchema);
+var McpServersSchema = z22.record(z22.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 = z24.extend(McpServerSchema, {
-  targets: z24.optional(RulesyncTargetsSchema),
-  description: z24.optional(z24.string()),
-  exposed: z24.optional(z24.boolean())
+var RulesyncMcpServerSchema = z23.extend(McpServerSchema, {
+  targets: z23.optional(RulesyncTargetsSchema),
+  description: z23.optional(z23.string()),
+  exposed: z23.optional(z23.boolean())
 });
-var RulesyncMcpConfigSchema = z24.object({
-  mcpServers: z24.record(z24.string(), RulesyncMcpServerSchema)
+var RulesyncMcpConfigSchema = z23.object({
+  mcpServers: z23.record(z23.string(), RulesyncMcpServerSchema)
 });
-var RulesyncMcpFileSchema = z24.looseObject({
-  $schema: z24.optional(z24.string()),
+var RulesyncMcpFileSchema = z23.looseObject({
+  $schema: z23.optional(z23.string()),
   ...RulesyncMcpConfigSchema.shape
 });
 var RulesyncMcp = class _RulesyncMcp extends RulesyncFile {
@@ -8201,25 +8179,25 @@ var JunieMcp = class _JunieMcp extends ToolMcp {
 // src/features/mcp/kilo-mcp.ts
 import { join as join56 } from "path";
 import { parse as parseJsonc3 } from "jsonc-parser";
-import { z as z25 } from "zod/mini";
-var KiloMcpLocalServerSchema = z25.object({
-  type: z25.literal("local"),
-  command: z25.array(z25.string()),
-  environment: z25.optional(z25.record(z25.string(), z25.string())),
-  enabled: z25._default(z25.boolean(), true),
-  cwd: z25.optional(z25.string())
+import { z as z24 } from "zod/mini";
+var KiloMcpLocalServerSchema = z24.object({
+  type: z24.literal("local"),
+  command: z24.array(z24.string()),
+  environment: z24.optional(z24.record(z24.string(), z24.string())),
+  enabled: z24._default(z24.boolean(), true),
+  cwd: z24.optional(z24.string())
 });
-var KiloMcpRemoteServerSchema = z25.object({
-  type: z25.literal("remote"),
-  url: z25.string(),
-  headers: z25.optional(z25.record(z25.string(), z25.string())),
-  enabled: z25._default(z25.boolean(), true)
+var KiloMcpRemoteServerSchema = z24.object({
+  type: z24.literal("remote"),
+  url: z24.string(),
+  headers: z24.optional(z24.record(z24.string(), z24.string())),
+  enabled: z24._default(z24.boolean(), true)
 });
-var KiloMcpServerSchema = z25.union([KiloMcpLocalServerSchema, KiloMcpRemoteServerSchema]);
-var KiloConfigSchema = z25.looseObject({
-  $schema: z25.optional(z25.string()),
-  mcp: z25.optional(z25.record(z25.string(), KiloMcpServerSchema)),
-  tools: z25.optional(z25.record(z25.string(), z25.boolean()))
+var KiloMcpServerSchema = z24.union([KiloMcpLocalServerSchema, KiloMcpRemoteServerSchema]);
+var KiloConfigSchema = z24.looseObject({
+  $schema: z24.optional(z24.string()),
+  mcp: z24.optional(z24.record(z24.string(), KiloMcpServerSchema)),
+  tools: z24.optional(z24.record(z24.string(), z24.boolean()))
 });
 function convertFromKiloFormat(kiloMcp, tools) {
   return Object.fromEntries(
@@ -8516,28 +8494,28 @@ var KiroMcp = class _KiroMcp extends ToolMcp {
 // src/features/mcp/opencode-mcp.ts
 import { join as join58 } from "path";
 import { parse as parseJsonc4 } from "jsonc-parser";
-import { z as z26 } from "zod/mini";
-var OpencodeMcpLocalServerSchema = z26.object({
-  type: z26.literal("local"),
-  command: z26.array(z26.string()),
-  environment: z26.optional(z26.record(z26.string(), z26.string())),
-  enabled: z26._default(z26.boolean(), true),
-  cwd: z26.optional(z26.string())
+import { z as z25 } from "zod/mini";
+var OpencodeMcpLocalServerSchema = z25.object({
+  type: z25.literal("local"),
+  command: z25.array(z25.string()),
+  environment: z25.optional(z25.record(z25.string(), z25.string())),
+  enabled: z25._default(z25.boolean(), true),
+  cwd: z25.optional(z25.string())
 });
-var OpencodeMcpRemoteServerSchema = z26.object({
-  type: z26.literal("remote"),
-  url: z26.string(),
-  headers: z26.optional(z26.record(z26.string(), z26.string())),
-  enabled: z26._default(z26.boolean(), true)
+var OpencodeMcpRemoteServerSchema = z25.object({
+  type: z25.literal("remote"),
+  url: z25.string(),
+  headers: z25.optional(z25.record(z25.string(), z25.string())),
+  enabled: z25._default(z25.boolean(), true)
 });
-var OpencodeMcpServerSchema = z26.union([
+var OpencodeMcpServerSchema = z25.union([
   OpencodeMcpLocalServerSchema,
   OpencodeMcpRemoteServerSchema
 ]);
-var OpencodeConfigSchema = z26.looseObject({
-  $schema: z26.optional(z26.string()),
-  mcp: z26.optional(z26.record(z26.string(), OpencodeMcpServerSchema)),
-  tools: z26.optional(z26.record(z26.string(), z26.boolean()))
+var OpencodeConfigSchema = z25.looseObject({
+  $schema: z25.optional(z25.string()),
+  mcp: z25.optional(z25.record(z25.string(), OpencodeMcpServerSchema)),
+  tools: z25.optional(z25.record(z25.string(), z25.boolean()))
 });
 function convertFromOpencodeFormat(opencodeMcp, tools) {
   return Object.fromEntries(
@@ -9008,7 +8986,7 @@ var mcpProcessorToolTargetTuple = [
   "roo",
   "rovodev"
 ];
-var McpProcessorToolTargetSchema = z27.enum(mcpProcessorToolTargetTuple);
+var McpProcessorToolTargetSchema = z26.enum(mcpProcessorToolTargetTuple);
 var toolMcpFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -9347,7 +9325,7 @@ var McpProcessor = class extends FeatureProcessor {
 };
 
 // src/features/permissions/permissions-processor.ts
-import { z as z32 } from "zod/mini";
+import { z as z31 } from "zod/mini";
 
 // src/features/permissions/claudecode-permissions.ts
 import { join as join62 } from "path";
@@ -9357,14 +9335,14 @@ import { uniq as uniq3 } from "es-toolkit";
 import { join as join61 } from "path";
 
 // src/types/permissions.ts
-import { z as z28 } from "zod/mini";
-var PermissionActionSchema = z28.enum(["allow", "ask", "deny"]);
-var PermissionRulesSchema = z28.record(z28.string(), PermissionActionSchema);
-var PermissionsConfigSchema = z28.looseObject({
-  permission: z28.record(z28.string(), PermissionRulesSchema)
+import { z as z27 } from "zod/mini";
+var PermissionActionSchema = z27.enum(["allow", "ask", "deny"]);
+var PermissionRulesSchema = z27.record(z27.string(), PermissionActionSchema);
+var PermissionsConfigSchema = z27.looseObject({
+  permission: z27.record(z27.string(), PermissionRulesSchema)
 });
-var RulesyncPermissionsFileSchema = z28.looseObject({
-  $schema: z28.optional(z28.string()),
+var RulesyncPermissionsFileSchema = z27.looseObject({
+  $schema: z27.optional(z27.string()),
   ...PermissionsConfigSchema.shape
 });
 
@@ -9934,7 +9912,7 @@ function mapBashActionToDecision(action) {
 // src/features/permissions/geminicli-permissions.ts
 import { join as join64 } from "path";
 import * as smolToml5 from "smol-toml";
-import { z as z29 } from "zod/mini";
+import { z as z28 } from "zod/mini";
 var GEMINICLI_POLICY_RELATIVE_DIR_PATH = join64(".gemini", "policies");
 var GEMINICLI_POLICY_FILE_NAME = "rulesync.toml";
 var RULESYNC_TO_GEMINICLI_TOOL_NAME = {
@@ -10262,14 +10240,14 @@ function regexToGlobPattern(regex) {
   }
   return glob;
 }
-var GeminicliPolicyRuleSchema = z29.looseObject({
-  toolName: z29.string(),
-  decision: z29.optional(z29.unknown()),
-  commandPrefix: z29.optional(z29.string()),
-  argsPattern: z29.optional(z29.string())
+var GeminicliPolicyRuleSchema = z28.looseObject({
+  toolName: z28.string(),
+  decision: z28.optional(z28.unknown()),
+  commandPrefix: z28.optional(z28.string()),
+  argsPattern: z28.optional(z28.string())
 });
-var GeminicliPolicyFileSchema = z29.looseObject({
-  rule: z29.optional(z29.array(z29.looseObject({})))
+var GeminicliPolicyFileSchema = z28.looseObject({
+  rule: z28.optional(z28.array(z28.looseObject({})))
 });
 function extractRules(parsed, logger) {
   const parsedFile = GeminicliPolicyFileSchema.safeParse(parsed);
@@ -10305,12 +10283,12 @@ function extractPattern(rule) {
 
 // src/features/permissions/kiro-permissions.ts
 import { join as join65 } from "path";
-import { z as z30 } from "zod/mini";
-var KiroAgentSchema = z30.looseObject({
-  allowedTools: z30.optional(z30.array(z30.string())),
-  toolsSettings: z30.optional(z30.record(z30.string(), z30.unknown()))
+import { z as z29 } from "zod/mini";
+var KiroAgentSchema = z29.looseObject({
+  allowedTools: z29.optional(z29.array(z29.string())),
+  toolsSettings: z29.optional(z29.record(z29.string(), z29.unknown()))
 });
-var UnknownRecordSchema = z30.record(z30.string(), z30.unknown());
+var UnknownRecordSchema = z29.record(z29.string(), z29.unknown());
 var KiroPermissions = class _KiroPermissions extends ToolPermissions {
   static getSettablePaths(_options = {}) {
     return {
@@ -10463,8 +10441,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.`);
       }
@@ -10490,13 +10472,13 @@ function asStringArray(value) {
 // src/features/permissions/opencode-permissions.ts
 import { join as join66 } from "path";
 import { parse as parseJsonc5 } from "jsonc-parser";
-import { z as z31 } from "zod/mini";
-var OpencodePermissionSchema = z31.union([
-  z31.enum(["allow", "ask", "deny"]),
-  z31.record(z31.string(), z31.enum(["allow", "ask", "deny"]))
+import { z as z30 } from "zod/mini";
+var OpencodePermissionSchema = z30.union([
+  z30.enum(["allow", "ask", "deny"]),
+  z30.record(z30.string(), z30.enum(["allow", "ask", "deny"]))
 ]);
-var OpencodePermissionsConfigSchema = z31.looseObject({
-  permission: z31.optional(z31.record(z31.string(), OpencodePermissionSchema))
+var OpencodePermissionsConfigSchema = z30.looseObject({
+  permission: z30.optional(z30.record(z30.string(), OpencodePermissionSchema))
 });
 var OpencodePermissions = class _OpencodePermissions extends ToolPermissions {
   json;
@@ -10627,7 +10609,7 @@ var permissionsProcessorToolTargetTuple = [
   "kiro",
   "opencode"
 ];
-var PermissionsProcessorToolTargetSchema = z32.enum(permissionsProcessorToolTargetTuple);
+var PermissionsProcessorToolTargetSchema = z31.enum(permissionsProcessorToolTargetTuple);
 var toolPermissionsFactories = /* @__PURE__ */ new Map([
   [
     "claudecode",
@@ -10792,7 +10774,7 @@ var PermissionsProcessor = class extends FeatureProcessor {
 // src/features/rules/rules-processor.ts
 import { basename as basename10, dirname as dirname3, join as join137, relative as relative5 } from "path";
 import { encode } from "@toon-format/toon";
-import { z as z72 } from "zod/mini";
+import { z as z71 } from "zod/mini";
 
 // src/constants/general.ts
 var SKILL_FILE_NAME = "SKILL.md";
@@ -10802,7 +10784,7 @@ import { join as join70 } from "path";
 
 // src/features/skills/simulated-skill.ts
 import { join as join69 } from "path";
-import { z as z33 } from "zod/mini";
+import { z as z32 } from "zod/mini";
 
 // src/features/skills/tool-skill.ts
 import { join as join68 } from "path";
@@ -11039,9 +11021,9 @@ var ToolSkill = class extends AiDir {
 };
 
 // src/features/skills/simulated-skill.ts
-var SimulatedSkillFrontmatterSchema = z33.looseObject({
-  name: z33.string(),
-  description: z33.string()
+var SimulatedSkillFrontmatterSchema = z32.looseObject({
+  name: z32.string(),
+  description: z32.string()
 });
 var SimulatedSkill = class extends ToolSkill {
   frontmatter;
@@ -11268,49 +11250,49 @@ var FactorydroidSkill = class _FactorydroidSkill extends SimulatedSkill {
 
 // src/features/skills/rovodev-skill.ts
 import { join as join73 } from "path";
-import { z as z35 } from "zod/mini";
+import { z as z34 } from "zod/mini";
 
 // src/features/skills/rulesync-skill.ts
 import { join as join72 } from "path";
-import { z as z34 } from "zod/mini";
-var RulesyncSkillFrontmatterSchemaInternal = z34.looseObject({
-  name: z34.string(),
-  description: z34.string(),
-  targets: z34._default(RulesyncTargetsSchema, ["*"]),
-  claudecode: z34.optional(
-    z34.looseObject({
-      "allowed-tools": z34.optional(z34.array(z34.string())),
-      model: z34.optional(z34.string()),
-      "disable-model-invocation": z34.optional(z34.boolean())
+import { z as z33 } from "zod/mini";
+var RulesyncSkillFrontmatterSchemaInternal = z33.looseObject({
+  name: z33.string(),
+  description: z33.string(),
+  targets: z33._default(RulesyncTargetsSchema, ["*"]),
+  claudecode: z33.optional(
+    z33.looseObject({
+      "allowed-tools": z33.optional(z33.array(z33.string())),
+      model: z33.optional(z33.string()),
+      "disable-model-invocation": z33.optional(z33.boolean())
     })
   ),
-  codexcli: z34.optional(
-    z34.looseObject({
-      "short-description": z34.optional(z34.string())
+  codexcli: z33.optional(
+    z33.looseObject({
+      "short-description": z33.optional(z33.string())
     })
   ),
-  opencode: z34.optional(
-    z34.looseObject({
-      "allowed-tools": z34.optional(z34.array(z34.string()))
+  opencode: z33.optional(
+    z33.looseObject({
+      "allowed-tools": z33.optional(z33.array(z33.string()))
     })
   ),
-  kilo: z34.optional(
-    z34.looseObject({
-      "allowed-tools": z34.optional(z34.array(z34.string()))
+  kilo: z33.optional(
+    z33.looseObject({
+      "allowed-tools": z33.optional(z33.array(z33.string()))
     })
   ),
-  deepagents: z34.optional(
-    z34.looseObject({
-      "allowed-tools": z34.optional(z34.array(z34.string()))
+  deepagents: z33.optional(
+    z33.looseObject({
+      "allowed-tools": z33.optional(z33.array(z33.string()))
     })
   ),
-  copilot: z34.optional(
-    z34.looseObject({
-      license: z34.optional(z34.string())
+  copilot: z33.optional(
+    z33.looseObject({
+      license: z33.optional(z33.string())
     })
   ),
-  cline: z34.optional(z34.looseObject({})),
-  roo: z34.optional(z34.looseObject({}))
+  cline: z33.optional(z33.looseObject({})),
+  roo: z33.optional(z33.looseObject({}))
 });
 var RulesyncSkillFrontmatterSchema = RulesyncSkillFrontmatterSchemaInternal;
 var RulesyncSkill = class _RulesyncSkill extends AiDir {
@@ -11407,9 +11389,9 @@ var RulesyncSkill = class _RulesyncSkill extends AiDir {
 };
 
 // src/features/skills/rovodev-skill.ts
-var RovodevSkillFrontmatterSchema = z35.looseObject({
-  name: z35.string(),
-  description: z35.string()
+var RovodevSkillFrontmatterSchema = z34.looseObject({
+  name: z34.string(),
+  description: z34.string()
 });
 var RovodevSkill = class _RovodevSkill extends ToolSkill {
   constructor({
@@ -11581,7 +11563,7 @@ var RovodevSkill = class _RovodevSkill extends ToolSkill {
 
 // src/features/skills/skills-processor.ts
 import { basename as basename5, join as join92 } from "path";
-import { z as z52 } from "zod/mini";
+import { z as z51 } from "zod/mini";
 
 // src/types/dir-feature-processor.ts
 import { join as join74 } from "path";
@@ -11720,10 +11702,10 @@ var DirFeatureProcessor = class {
 
 // src/features/skills/agentsskills-skill.ts
 import { join as join75 } from "path";
-import { z as z36 } from "zod/mini";
-var AgentsSkillsSkillFrontmatterSchema = z36.looseObject({
-  name: z36.string(),
-  description: z36.string()
+import { z as z35 } from "zod/mini";
+var AgentsSkillsSkillFrontmatterSchema = z35.looseObject({
+  name: z35.string(),
+  description: z35.string()
 });
 var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
   constructor({
@@ -11878,10 +11860,10 @@ var AgentsSkillsSkill = class _AgentsSkillsSkill extends ToolSkill {
 
 // src/features/skills/antigravity-skill.ts
 import { join as join76 } from "path";
-import { z as z37 } from "zod/mini";
-var AntigravitySkillFrontmatterSchema = z37.looseObject({
-  name: z37.string(),
-  description: z37.string()
+import { z as z36 } from "zod/mini";
+var AntigravitySkillFrontmatterSchema = z36.looseObject({
+  name: z36.string(),
+  description: z36.string()
 });
 var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
   constructor({
@@ -12039,13 +12021,13 @@ var AntigravitySkill = class _AntigravitySkill extends ToolSkill {
 
 // src/features/skills/claudecode-skill.ts
 import { join as join77 } from "path";
-import { z as z38 } from "zod/mini";
-var ClaudecodeSkillFrontmatterSchema = z38.looseObject({
-  name: z38.string(),
-  description: z38.string(),
-  "allowed-tools": z38.optional(z38.array(z38.string())),
-  model: z38.optional(z38.string()),
-  "disable-model-invocation": z38.optional(z38.boolean())
+import { z as z37 } from "zod/mini";
+var ClaudecodeSkillFrontmatterSchema = z37.looseObject({
+  name: z37.string(),
+  description: z37.string(),
+  "allowed-tools": z37.optional(z37.array(z37.string())),
+  model: z37.optional(z37.string()),
+  "disable-model-invocation": z37.optional(z37.boolean())
 });
 var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
   constructor({
@@ -12215,10 +12197,10 @@ var ClaudecodeSkill = class _ClaudecodeSkill extends ToolSkill {
 
 // src/features/skills/cline-skill.ts
 import { join as join78 } from "path";
-import { z as z39 } from "zod/mini";
-var ClineSkillFrontmatterSchema = z39.looseObject({
-  name: z39.string(),
-  description: z39.string()
+import { z as z38 } from "zod/mini";
+var ClineSkillFrontmatterSchema = z38.looseObject({
+  name: z38.string(),
+  description: z38.string()
 });
 var ClineSkill = class _ClineSkill extends ToolSkill {
   constructor({
@@ -12388,13 +12370,13 @@ var ClineSkill = class _ClineSkill extends ToolSkill {
 
 // src/features/skills/codexcli-skill.ts
 import { join as join79 } from "path";
-import { z as z40 } from "zod/mini";
-var CodexCliSkillFrontmatterSchema = z40.looseObject({
-  name: z40.string(),
-  description: z40.string(),
-  metadata: z40.optional(
-    z40.looseObject({
-      "short-description": z40.optional(z40.string())
+import { z as z39 } from "zod/mini";
+var CodexCliSkillFrontmatterSchema = z39.looseObject({
+  name: z39.string(),
+  description: z39.string(),
+  metadata: z39.optional(
+    z39.looseObject({
+      "short-description": z39.optional(z39.string())
     })
   )
 });
@@ -12559,11 +12541,11 @@ var CodexCliSkill = class _CodexCliSkill extends ToolSkill {
 
 // src/features/skills/copilot-skill.ts
 import { join as join80 } from "path";
-import { z as z41 } from "zod/mini";
-var CopilotSkillFrontmatterSchema = z41.looseObject({
-  name: z41.string(),
-  description: z41.string(),
-  license: z41.optional(z41.string())
+import { z as z40 } from "zod/mini";
+var CopilotSkillFrontmatterSchema = z40.looseObject({
+  name: z40.string(),
+  description: z40.string(),
+  license: z40.optional(z40.string())
 });
 var CopilotSkill = class _CopilotSkill extends ToolSkill {
   constructor({
@@ -12724,10 +12706,10 @@ var CopilotSkill = class _CopilotSkill extends ToolSkill {
 
 // src/features/skills/cursor-skill.ts
 import { join as join81 } from "path";
-import { z as z42 } from "zod/mini";
-var CursorSkillFrontmatterSchema = z42.looseObject({
-  name: z42.string(),
-  description: z42.string()
+import { z as z41 } from "zod/mini";
+var CursorSkillFrontmatterSchema = z41.looseObject({
+  name: z41.string(),
+  description: z41.string()
 });
 var CursorSkill = class _CursorSkill extends ToolSkill {
   constructor({
@@ -12879,11 +12861,11 @@ var CursorSkill = class _CursorSkill extends ToolSkill {
 
 // src/features/skills/deepagents-skill.ts
 import { join as join82 } from "path";
-import { z as z43 } from "zod/mini";
-var DeepagentsSkillFrontmatterSchema = z43.looseObject({
-  name: z43.string(),
-  description: z43.string(),
-  "allowed-tools": z43.optional(z43.array(z43.string()))
+import { z as z42 } from "zod/mini";
+var DeepagentsSkillFrontmatterSchema = z42.looseObject({
+  name: z42.string(),
+  description: z42.string(),
+  "allowed-tools": z42.optional(z42.array(z42.string()))
 });
 var DeepagentsSkill = class _DeepagentsSkill extends ToolSkill {
   constructor({
@@ -13041,10 +13023,10 @@ var DeepagentsSkill = class _DeepagentsSkill extends ToolSkill {
 
 // src/features/skills/geminicli-skill.ts
 import { join as join83 } from "path";
-import { z as z44 } from "zod/mini";
-var GeminiCliSkillFrontmatterSchema = z44.looseObject({
-  name: z44.string(),
-  description: z44.string()
+import { z as z43 } from "zod/mini";
+var GeminiCliSkillFrontmatterSchema = z43.looseObject({
+  name: z43.string(),
+  description: z43.string()
 });
 var GeminiCliSkill = class _GeminiCliSkill extends ToolSkill {
   constructor({
@@ -13198,10 +13180,10 @@ var GeminiCliSkill = class _GeminiCliSkill extends ToolSkill {
 
 // src/features/skills/junie-skill.ts
 import { join as join84 } from "path";
-import { z as z45 } from "zod/mini";
-var JunieSkillFrontmatterSchema = z45.looseObject({
-  name: z45.string(),
-  description: z45.string()
+import { z as z44 } from "zod/mini";
+var JunieSkillFrontmatterSchema = z44.looseObject({
+  name: z44.string(),
+  description: z44.string()
 });
 var JunieSkill = class _JunieSkill extends ToolSkill {
   constructor({
@@ -13374,11 +13356,11 @@ var JunieSkill = class _JunieSkill extends ToolSkill {
 
 // src/features/skills/kilo-skill.ts
 import { join as join85 } from "path";
-import { z as z46 } from "zod/mini";
-var KiloSkillFrontmatterSchema = z46.looseObject({
-  name: z46.string(),
-  description: z46.string(),
-  "allowed-tools": z46.optional(z46.array(z46.string()))
+import { z as z45 } from "zod/mini";
+var KiloSkillFrontmatterSchema = z45.looseObject({
+  name: z45.string(),
+  description: z45.string(),
+  "allowed-tools": z45.optional(z45.array(z45.string()))
 });
 var KiloSkill = class _KiloSkill extends ToolSkill {
   constructor({
@@ -13535,10 +13517,10 @@ var KiloSkill = class _KiloSkill extends ToolSkill {
 
 // src/features/skills/kiro-skill.ts
 import { join as join86 } from "path";
-import { z as z47 } from "zod/mini";
-var KiroSkillFrontmatterSchema = z47.looseObject({
-  name: z47.string(),
-  description: z47.string()
+import { z as z46 } from "zod/mini";
+var KiroSkillFrontmatterSchema = z46.looseObject({
+  name: z46.string(),
+  description: z46.string()
 });
 var KiroSkill = class _KiroSkill extends ToolSkill {
   constructor({
@@ -13712,11 +13694,11 @@ var KiroSkill = class _KiroSkill extends ToolSkill {
 
 // src/features/skills/opencode-skill.ts
 import { join as join87 } from "path";
-import { z as z48 } from "zod/mini";
-var OpenCodeSkillFrontmatterSchema = z48.looseObject({
-  name: z48.string(),
-  description: z48.string(),
-  "allowed-tools": z48.optional(z48.array(z48.string()))
+import { z as z47 } from "zod/mini";
+var OpenCodeSkillFrontmatterSchema = z47.looseObject({
+  name: z47.string(),
+  description: z47.string(),
+  "allowed-tools": z47.optional(z47.array(z47.string()))
 });
 var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
   constructor({
@@ -13873,10 +13855,10 @@ var OpenCodeSkill = class _OpenCodeSkill extends ToolSkill {
 
 // src/features/skills/replit-skill.ts
 import { join as join88 } from "path";
-import { z as z49 } from "zod/mini";
-var ReplitSkillFrontmatterSchema = z49.looseObject({
-  name: z49.string(),
-  description: z49.string()
+import { z as z48 } from "zod/mini";
+var ReplitSkillFrontmatterSchema = z48.looseObject({
+  name: z48.string(),
+  description: z48.string()
 });
 var ReplitSkill = class _ReplitSkill extends ToolSkill {
   constructor({
@@ -14031,10 +14013,10 @@ var ReplitSkill = class _ReplitSkill extends ToolSkill {
 
 // src/features/skills/roo-skill.ts
 import { join as join89 } from "path";
-import { z as z50 } from "zod/mini";
-var RooSkillFrontmatterSchema = z50.looseObject({
-  name: z50.string(),
-  description: z50.string()
+import { z as z49 } from "zod/mini";
+var RooSkillFrontmatterSchema = z49.looseObject({
+  name: z49.string(),
+  description: z49.string()
 });
 var RooSkill = class _RooSkill extends ToolSkill {
   constructor({
@@ -14223,10 +14205,10 @@ async function getLocalSkillDirNames(baseDir) {
 
 // src/features/skills/windsurf-skill.ts
 import { join as join91 } from "path";
-import { z as z51 } from "zod/mini";
-var WindsurfSkillFrontmatterSchema = z51.looseObject({
-  name: z51.string(),
-  description: z51.string()
+import { z as z50 } from "zod/mini";
+var WindsurfSkillFrontmatterSchema = z50.looseObject({
+  name: z50.string(),
+  description: z50.string()
 });
 var WindsurfSkill = class _WindsurfSkill extends ToolSkill {
   constructor({
@@ -14404,7 +14386,7 @@ var skillsProcessorToolTargetTuple = [
   "rovodev",
   "windsurf"
 ];
-var SkillsProcessorToolTargetSchema = z52.enum(skillsProcessorToolTargetTuple);
+var SkillsProcessorToolTargetSchema = z51.enum(skillsProcessorToolTargetTuple);
 var toolSkillFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -14783,7 +14765,7 @@ import { join as join94 } from "path";
 
 // src/features/subagents/simulated-subagent.ts
 import { basename as basename6, join as join93 } from "path";
-import { z as z53 } from "zod/mini";
+import { z as z52 } from "zod/mini";
 
 // src/features/subagents/tool-subagent.ts
 var ToolSubagent = class extends ToolFile {
@@ -14835,9 +14817,9 @@ var ToolSubagent = class extends ToolFile {
 };
 
 // src/features/subagents/simulated-subagent.ts
-var SimulatedSubagentFrontmatterSchema = z53.object({
-  name: z53.string(),
-  description: z53.optional(z53.string())
+var SimulatedSubagentFrontmatterSchema = z52.object({
+  name: z52.string(),
+  description: z52.optional(z52.string())
 });
 var SimulatedSubagent = class extends ToolSubagent {
   frontmatter;
@@ -14995,15 +14977,15 @@ var FactorydroidSubagent = class _FactorydroidSubagent extends SimulatedSubagent
 
 // src/features/subagents/geminicli-subagent.ts
 import { join as join97 } from "path";
-import { z as z55 } from "zod/mini";
+import { z as z54 } from "zod/mini";
 
 // src/features/subagents/rulesync-subagent.ts
 import { basename as basename7, join as join96 } from "path";
-import { z as z54 } from "zod/mini";
-var RulesyncSubagentFrontmatterSchema = z54.looseObject({
-  targets: z54._default(RulesyncTargetsSchema, ["*"]),
-  name: z54.string(),
-  description: z54.optional(z54.string())
+import { z as z53 } from "zod/mini";
+var RulesyncSubagentFrontmatterSchema = z53.looseObject({
+  targets: z53._default(RulesyncTargetsSchema, ["*"]),
+  name: z53.string(),
+  description: z53.optional(z53.string())
 });
 var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
   frontmatter;
@@ -15072,9 +15054,9 @@ var RulesyncSubagent = class _RulesyncSubagent extends RulesyncFile {
 };
 
 // src/features/subagents/geminicli-subagent.ts
-var GeminiCliSubagentFrontmatterSchema = z55.looseObject({
-  name: z55.string(),
-  description: z55.optional(z55.string())
+var GeminiCliSubagentFrontmatterSchema = z54.looseObject({
+  name: z54.string(),
+  description: z54.optional(z54.string())
 });
 var GeminiCliSubagent = class _GeminiCliSubagent extends ToolSubagent {
   frontmatter;
@@ -15247,10 +15229,10 @@ var RooSubagent = class _RooSubagent extends SimulatedSubagent {
 
 // src/features/subagents/rovodev-subagent.ts
 import { join as join99 } from "path";
-import { z as z56 } from "zod/mini";
-var RovodevSubagentFrontmatterSchema = z56.looseObject({
-  name: z56.string(),
-  description: z56.optional(z56.string())
+import { z as z55 } from "zod/mini";
+var RovodevSubagentFrontmatterSchema = z55.looseObject({
+  name: z55.string(),
+  description: z55.optional(z55.string())
 });
 var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
   frontmatter;
@@ -15392,18 +15374,18 @@ var RovodevSubagent = class _RovodevSubagent extends ToolSubagent {
 
 // src/features/subagents/subagents-processor.ts
 import { basename as basename9, join as join110 } from "path";
-import { z as z65 } from "zod/mini";
+import { z as z64 } from "zod/mini";
 
 // src/features/subagents/claudecode-subagent.ts
 import { join as join100 } from "path";
-import { z as z57 } from "zod/mini";
-var ClaudecodeSubagentFrontmatterSchema = z57.looseObject({
-  name: z57.string(),
-  description: z57.optional(z57.string()),
-  model: z57.optional(z57.string()),
-  tools: z57.optional(z57.union([z57.string(), z57.array(z57.string())])),
-  permissionMode: z57.optional(z57.string()),
-  skills: z57.optional(z57.union([z57.string(), z57.array(z57.string())]))
+import { z as z56 } from "zod/mini";
+var ClaudecodeSubagentFrontmatterSchema = z56.looseObject({
+  name: z56.string(),
+  description: z56.optional(z56.string()),
+  model: z56.optional(z56.string()),
+  tools: z56.optional(z56.union([z56.string(), z56.array(z56.string())])),
+  permissionMode: z56.optional(z56.string()),
+  skills: z56.optional(z56.union([z56.string(), z56.array(z56.string())]))
 });
 var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
   frontmatter;
@@ -15559,14 +15541,14 @@ var ClaudecodeSubagent = class _ClaudecodeSubagent extends ToolSubagent {
 // src/features/subagents/codexcli-subagent.ts
 import { join as join101 } from "path";
 import * as smolToml6 from "smol-toml";
-import { z as z58 } from "zod/mini";
-var CodexCliSubagentTomlSchema = z58.looseObject({
-  name: z58.string(),
-  description: z58.optional(z58.string()),
-  developer_instructions: z58.optional(z58.string()),
-  model: z58.optional(z58.string()),
-  model_reasoning_effort: z58.optional(z58.string()),
-  sandbox_mode: z58.optional(z58.string())
+import { z as z57 } from "zod/mini";
+var CodexCliSubagentTomlSchema = z57.looseObject({
+  name: z57.string(),
+  description: z57.optional(z57.string()),
+  developer_instructions: z57.optional(z57.string()),
+  model: z57.optional(z57.string()),
+  model_reasoning_effort: z57.optional(z57.string()),
+  sandbox_mode: z57.optional(z57.string())
 });
 function stringifyCodexCliSubagentToml(tomlObj) {
   const { developer_instructions, ...restFields } = tomlObj;
@@ -15732,12 +15714,12 @@ var CodexCliSubagent = class _CodexCliSubagent extends ToolSubagent {
 
 // src/features/subagents/copilot-subagent.ts
 import { join as join102 } from "path";
-import { z as z59 } from "zod/mini";
+import { z as z58 } from "zod/mini";
 var REQUIRED_TOOL = "agent/runSubagent";
-var CopilotSubagentFrontmatterSchema = z59.looseObject({
-  name: z59.string(),
-  description: z59.optional(z59.string()),
-  tools: z59.optional(z59.union([z59.string(), z59.array(z59.string())]))
+var CopilotSubagentFrontmatterSchema = z58.looseObject({
+  name: z58.string(),
+  description: z58.optional(z58.string()),
+  tools: z58.optional(z58.union([z58.string(), z58.array(z58.string())]))
 });
 var normalizeTools = (tools) => {
   if (!tools) {
@@ -15749,6 +15731,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;
@@ -15795,7 +15792,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
     });
   }
@@ -15821,16 +15818,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
@@ -15902,10 +15895,10 @@ var CopilotSubagent = class _CopilotSubagent extends ToolSubagent {
 
 // src/features/subagents/cursor-subagent.ts
 import { join as join103 } from "path";
-import { z as z60 } from "zod/mini";
-var CursorSubagentFrontmatterSchema = z60.looseObject({
-  name: z60.string(),
-  description: z60.optional(z60.string())
+import { z as z59 } from "zod/mini";
+var CursorSubagentFrontmatterSchema = z59.looseObject({
+  name: z59.string(),
+  description: z59.optional(z59.string())
 });
 var CursorSubagent = class _CursorSubagent extends ToolSubagent {
   frontmatter;
@@ -16049,11 +16042,11 @@ var CursorSubagent = class _CursorSubagent extends ToolSubagent {
 
 // src/features/subagents/deepagents-subagent.ts
 import { join as join104 } from "path";
-import { z as z61 } from "zod/mini";
-var DeepagentsSubagentFrontmatterSchema = z61.looseObject({
-  name: z61.string(),
-  description: z61.optional(z61.string()),
-  model: z61.optional(z61.string())
+import { z as z60 } from "zod/mini";
+var DeepagentsSubagentFrontmatterSchema = z60.looseObject({
+  name: z60.string(),
+  description: z60.optional(z60.string()),
+  model: z60.optional(z60.string())
 });
 var DeepagentsSubagent = class _DeepagentsSubagent extends ToolSubagent {
   frontmatter;
@@ -16202,10 +16195,10 @@ var DeepagentsSubagent = class _DeepagentsSubagent extends ToolSubagent {
 
 // src/features/subagents/junie-subagent.ts
 import { join as join105 } from "path";
-import { z as z62 } from "zod/mini";
-var JunieSubagentFrontmatterSchema = z62.looseObject({
-  name: z62.optional(z62.string()),
-  description: z62.string()
+import { z as z61 } from "zod/mini";
+var JunieSubagentFrontmatterSchema = z61.looseObject({
+  name: z61.optional(z61.string()),
+  description: z61.string()
 });
 var JunieSubagent = class _JunieSubagent extends ToolSubagent {
   frontmatter;
@@ -16363,11 +16356,11 @@ import { join as join107 } from "path";
 
 // src/features/subagents/opencode-style-subagent.ts
 import { basename as basename8, join as join106 } from "path";
-import { z as z63 } from "zod/mini";
-var OpenCodeStyleSubagentFrontmatterSchema = z63.looseObject({
-  description: z63.optional(z63.string()),
-  mode: z63._default(z63.string(), "subagent"),
-  name: z63.optional(z63.string())
+import { z as z62 } from "zod/mini";
+var OpenCodeStyleSubagentFrontmatterSchema = z62.looseObject({
+  description: z62.optional(z62.string()),
+  mode: z62._default(z62.string(), "subagent"),
+  name: z62.optional(z62.string())
 });
 var OpenCodeStyleSubagent = class extends ToolSubagent {
   frontmatter;
@@ -16516,22 +16509,22 @@ var KiloSubagent = class _KiloSubagent extends OpenCodeStyleSubagent {
 
 // src/features/subagents/kiro-subagent.ts
 import { join as join108 } from "path";
-import { z as z64 } from "zod/mini";
-var KiroCliSubagentJsonSchema = z64.looseObject({
-  name: z64.string(),
-  description: z64.optional(z64.nullable(z64.string())),
-  prompt: z64.optional(z64.nullable(z64.string())),
-  tools: z64.optional(z64.nullable(z64.array(z64.string()))),
-  toolAliases: z64.optional(z64.nullable(z64.record(z64.string(), z64.string()))),
-  toolSettings: z64.optional(z64.nullable(z64.unknown())),
-  toolSchema: z64.optional(z64.nullable(z64.unknown())),
-  hooks: z64.optional(z64.nullable(z64.record(z64.string(), z64.array(z64.unknown())))),
-  model: z64.optional(z64.nullable(z64.string())),
-  mcpServers: z64.optional(z64.nullable(z64.record(z64.string(), z64.unknown()))),
-  useLegacyMcpJson: z64.optional(z64.nullable(z64.boolean())),
-  resources: z64.optional(z64.nullable(z64.array(z64.string()))),
-  allowedTools: z64.optional(z64.nullable(z64.array(z64.string()))),
-  includeMcpJson: z64.optional(z64.nullable(z64.boolean()))
+import { z as z63 } from "zod/mini";
+var KiroCliSubagentJsonSchema = z63.looseObject({
+  name: z63.string(),
+  description: z63.optional(z63.nullable(z63.string())),
+  prompt: z63.optional(z63.nullable(z63.string())),
+  tools: z63.optional(z63.nullable(z63.array(z63.string()))),
+  toolAliases: z63.optional(z63.nullable(z63.record(z63.string(), z63.string()))),
+  toolSettings: z63.optional(z63.nullable(z63.unknown())),
+  toolSchema: z63.optional(z63.nullable(z63.unknown())),
+  hooks: z63.optional(z63.nullable(z63.record(z63.string(), z63.array(z63.unknown())))),
+  model: z63.optional(z63.nullable(z63.string())),
+  mcpServers: z63.optional(z63.nullable(z63.record(z63.string(), z63.unknown()))),
+  useLegacyMcpJson: z63.optional(z63.nullable(z63.boolean())),
+  resources: z63.optional(z63.nullable(z63.array(z63.string()))),
+  allowedTools: z63.optional(z63.nullable(z63.array(z63.string()))),
+  includeMcpJson: z63.optional(z63.nullable(z63.boolean()))
 });
 var KiroSubagent = class _KiroSubagent extends ToolSubagent {
   body;
@@ -16792,7 +16785,7 @@ var subagentsProcessorToolTargetTuple = [
   "roo",
   "rovodev"
 ];
-var SubagentsProcessorToolTargetSchema = z65.enum(subagentsProcessorToolTargetTuple);
+var SubagentsProcessorToolTargetSchema = z64.enum(subagentsProcessorToolTargetTuple);
 var toolSubagentFactories = /* @__PURE__ */ new Map([
   [
     "agentsmd",
@@ -17102,42 +17095,42 @@ import { join as join112 } from "path";
 
 // src/features/rules/rulesync-rule.ts
 import { join as join111 } from "path";
-import { z as z66 } from "zod/mini";
-var RulesyncRuleFrontmatterSchema = z66.object({
-  root: z66.optional(z66.boolean()),
-  localRoot: z66.optional(z66.boolean()),
-  targets: z66._default(RulesyncTargetsSchema, ["*"]),
-  description: z66.optional(z66.string()),
-  globs: z66.optional(z66.array(z66.string())),
-  agentsmd: z66.optional(
-    z66.looseObject({
+import { z as z65 } from "zod/mini";
+var RulesyncRuleFrontmatterSchema = z65.object({
+  root: z65.optional(z65.boolean()),
+  localRoot: z65.optional(z65.boolean()),
+  targets: z65._default(RulesyncTargetsSchema, ["*"]),
+  description: z65.optional(z65.string()),
+  globs: z65.optional(z65.array(z65.string())),
+  agentsmd: z65.optional(
+    z65.looseObject({
       // @example "path/to/subproject"
-      subprojectPath: z66.optional(z66.string())
+      subprojectPath: z65.optional(z65.string())
     })
   ),
-  claudecode: z66.optional(
-    z66.looseObject({
+  claudecode: z65.optional(
+    z65.looseObject({
       // Glob patterns for conditional rules (takes precedence over globs)
       // @example ["src/**/*.ts", "tests/**/*.test.ts"]
-      paths: z66.optional(z66.array(z66.string()))
+      paths: z65.optional(z65.array(z65.string()))
     })
   ),
-  cursor: z66.optional(
-    z66.looseObject({
-      alwaysApply: z66.optional(z66.boolean()),
-      description: z66.optional(z66.string()),
-      globs: z66.optional(z66.array(z66.string()))
+  cursor: z65.optional(
+    z65.looseObject({
+      alwaysApply: z65.optional(z65.boolean()),
+      description: z65.optional(z65.string()),
+      globs: z65.optional(z65.array(z65.string()))
     })
   ),
-  copilot: z66.optional(
-    z66.looseObject({
-      excludeAgent: z66.optional(z66.union([z66.literal("code-review"), z66.literal("coding-agent")]))
+  copilot: z65.optional(
+    z65.looseObject({
+      excludeAgent: z65.optional(z65.union([z65.literal("code-review"), z65.literal("coding-agent")]))
     })
   ),
-  antigravity: z66.optional(
-    z66.looseObject({
-      trigger: z66.optional(z66.string()),
-      globs: z66.optional(z66.array(z66.string()))
+  antigravity: z65.optional(
+    z65.looseObject({
+      trigger: z65.optional(z65.string()),
+      globs: z65.optional(z65.array(z65.string()))
     })
   )
 });
@@ -17437,20 +17430,20 @@ var AgentsMdRule = class _AgentsMdRule extends ToolRule {
 
 // src/features/rules/antigravity-rule.ts
 import { join as join114 } from "path";
-import { z as z67 } from "zod/mini";
-var AntigravityRuleFrontmatterSchema = z67.looseObject({
-  trigger: z67.optional(
-    z67.union([
-      z67.literal("always_on"),
-      z67.literal("glob"),
-      z67.literal("manual"),
-      z67.literal("model_decision"),
-      z67.string()
+import { z as z66 } from "zod/mini";
+var AntigravityRuleFrontmatterSchema = z66.looseObject({
+  trigger: z66.optional(
+    z66.union([
+      z66.literal("always_on"),
+      z66.literal("glob"),
+      z66.literal("manual"),
+      z66.literal("model_decision"),
+      z66.string()
       // accepts any string for forward compatibility
     ])
   ),
-  globs: z67.optional(z67.string()),
-  description: z67.optional(z67.string())
+  globs: z66.optional(z66.string()),
+  description: z66.optional(z66.string())
 });
 function parseGlobsString(globs) {
   if (!globs) {
@@ -18037,9 +18030,9 @@ var ClaudecodeLegacyRule = class _ClaudecodeLegacyRule extends ToolRule {
 
 // src/features/rules/claudecode-rule.ts
 import { join as join118 } from "path";
-import { z as z68 } from "zod/mini";
-var ClaudecodeRuleFrontmatterSchema = z68.object({
-  paths: z68.optional(z68.array(z68.string()))
+import { z as z67 } from "zod/mini";
+var ClaudecodeRuleFrontmatterSchema = z67.object({
+  paths: z67.optional(z67.array(z67.string()))
 });
 var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
   frontmatter;
@@ -18255,9 +18248,9 @@ var ClaudecodeRule = class _ClaudecodeRule extends ToolRule {
 
 // src/features/rules/cline-rule.ts
 import { join as join119 } from "path";
-import { z as z69 } from "zod/mini";
-var ClineRuleFrontmatterSchema = z69.object({
-  description: z69.string()
+import { z as z68 } from "zod/mini";
+var ClineRuleFrontmatterSchema = z68.object({
+  description: z68.string()
 });
 var ClineRule = class _ClineRule extends ToolRule {
   static getSettablePaths(_options = {}) {
@@ -18436,11 +18429,11 @@ var CodexcliRule = class _CodexcliRule extends ToolRule {
 
 // src/features/rules/copilot-rule.ts
 import { join as join121 } from "path";
-import { z as z70 } from "zod/mini";
-var CopilotRuleFrontmatterSchema = z70.object({
-  description: z70.optional(z70.string()),
-  applyTo: z70.optional(z70.string()),
-  excludeAgent: z70.optional(z70.union([z70.literal("code-review"), z70.literal("coding-agent")]))
+import { z as z69 } from "zod/mini";
+var CopilotRuleFrontmatterSchema = z69.object({
+  description: z69.optional(z69.string()),
+  applyTo: z69.optional(z69.string()),
+  excludeAgent: z69.optional(z69.union([z69.literal("code-review"), z69.literal("coding-agent")]))
 });
 var CopilotRule = class _CopilotRule extends ToolRule {
   frontmatter;
@@ -18682,11 +18675,11 @@ var CopilotcliRule = class _CopilotcliRule extends CopilotRule {
 
 // src/features/rules/cursor-rule.ts
 import { join as join122 } from "path";
-import { z as z71 } from "zod/mini";
-var CursorRuleFrontmatterSchema = z71.object({
-  description: z71.optional(z71.string()),
-  globs: z71.optional(z71.string()),
-  alwaysApply: z71.optional(z71.boolean())
+import { z as z70 } from "zod/mini";
+var CursorRuleFrontmatterSchema = z70.object({
+  description: z70.optional(z70.string()),
+  globs: z70.optional(z70.string()),
+  alwaysApply: z70.optional(z70.boolean())
 });
 var CursorRule = class _CursorRule extends ToolRule {
   frontmatter;
@@ -20346,11 +20339,11 @@ var rulesProcessorToolTargets = [
   "warp",
   "windsurf"
 ];
-var RulesProcessorToolTargetSchema = z72.enum(rulesProcessorToolTargets);
+var RulesProcessorToolTargetSchema = z71.enum(rulesProcessorToolTargets);
 var formatRulePaths = (rules) => rules.map((r) => join137(r.getRelativeDirPath(), r.getRelativeFilePath())).join(", ");
-var RulesFeatureOptionsSchema = z72.looseObject({
-  ruleDiscoveryMode: z72.optional(z72.enum(["none", "explicit"])),
-  includeLocalRoot: z72.optional(z72.boolean())
+var RulesFeatureOptionsSchema = z71.looseObject({
+  ruleDiscoveryMode: z71.optional(z71.enum(["none", "explicit"])),
+  includeLocalRoot: z71.optional(z71.boolean())
 });
 var resolveRuleDiscoveryMode = ({
   defaultMode,
@@ -20371,8 +20364,8 @@ var resolveRuleDiscoveryMode = ({
   }
   return parsed.data.ruleDiscoveryMode === "none" ? "auto" : "toon";
 };
-var IncludeLocalRootSchema = z72.looseObject({
-  includeLocalRoot: z72.optional(z72.boolean())
+var IncludeLocalRootSchema = z71.looseObject({
+  includeLocalRoot: z71.optional(z71.boolean())
 });
 var resolveIncludeLocalRoot = (options) => {
   if (!options) return true;
@@ -22003,6 +21996,7 @@ export {
   RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
   RULESYNC_MCP_RELATIVE_FILE_PATH,
   RULESYNC_HOOKS_RELATIVE_FILE_PATH,
+  RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH,
   RULESYNC_AIIGNORE_FILE_NAME,
   RULESYNC_AIIGNORE_RELATIVE_FILE_PATH,
   RULESYNC_IGNORE_RELATIVE_FILE_PATH,
@@ -22031,6 +22025,7 @@ export {
   findFilesByGlobs,
   removeDirectory,
   removeFile,
+  getHomeDirectory,
   createTempDirectory,
   removeTempDirectory,
   ALL_FEATURES,
@@ -22051,6 +22046,7 @@ export {
   IgnoreProcessor,
   RulesyncMcp,
   McpProcessor,
+  RulesyncPermissions,
   ErrorCodes,
   CLIError,
   ConsoleLogger,