rulesync 8.30.1 → 8.32.0

package/dist/cli/index.js

@@ -4,28 +4,29 @@ import {
   ALL_FEATURES_WITH_WILDCARD,
   ALL_TOOL_TARGETS,
   ALL_TOOL_TARGETS_WITH_WILDCARD,
-  CLAUDECODE_AGENTS_DIR_PATH,
-  CLAUDECODE_COMMANDS_DIR_PATH,
   CLAUDECODE_DIR,
   CLAUDECODE_LOCAL_RULE_FILE_NAME,
-  CLAUDECODE_MCP_FILE_NAME,
   CLAUDECODE_MEMORIES_DIR_NAME,
-  CLAUDECODE_RULES_DIR_NAME,
-  CLAUDECODE_RULE_FILE_NAME,
   CLAUDECODE_SETTINGS_LOCAL_FILE_NAME,
   CLAUDECODE_SKILLS_DIR_PATH,
   CLIError,
   CommandsProcessor,
+  CommandsProcessorToolTargetSchema,
   ConfigResolver,
   ConsoleLogger,
   ErrorCodes,
   FETCH_CONCURRENCY_LIMIT,
   GITIGNORE_DESTINATION_KEY,
   HooksProcessor,
+  HooksProcessorToolTargetSchema,
   IgnoreProcessor,
+  IgnoreProcessorToolTargetSchema,
   JsonLogger,
   MAX_FILE_SIZE,
   McpProcessor,
+  McpProcessorToolTargetSchema,
+  PermissionsProcessor,
+  PermissionsProcessorToolTargetSchema,
   RULESYNC_AIIGNORE_FILE_NAME,
   RULESYNC_AIIGNORE_RELATIVE_FILE_PATH,
   RULESYNC_COMMANDS_RELATIVE_DIR_PATH,
@@ -48,6 +49,7 @@ import {
   RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH,
   RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH,
   RulesProcessor,
+  RulesProcessorToolTargetSchema,
   RulesyncCommand,
   RulesyncCommandFrontmatterSchema,
   RulesyncHooks,
@@ -62,7 +64,9 @@ import {
   RulesyncSubagentFrontmatterSchema,
   SKILL_FILE_NAME,
   SkillsProcessor,
+  SkillsProcessorToolTargetSchema,
   SubagentsProcessor,
+  SubagentsProcessorToolTargetSchema,
   ToolTargetSchema,
   checkPathTraversal,
   checkRulesyncDirExists,
@@ -88,8 +92,16 @@ import {
   removeTempDirectory,
   stringifyFrontmatter,
   toPosixPath,
+  toolCommandFactories,
+  toolHooksFactories,
+  toolIgnoreFactories,
+  toolMcpFactories,
+  toolPermissionsFactories,
+  toolRuleFactories,
+  toolSkillFactories,
+  toolSubagentFactories,
   writeFileContent
-} from "../chunk-DF7KWJTN.js";
+} from "../chunk-3SMTK3M3.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1142,8 +1154,11 @@ function logFeatureResult(logger5, params) {
     }
   }
 }
-async function generateCommand(logger5, options) {
-  const { baseDir, outputRoots, ...rest } = options;
+function resolveOutputRoots({
+  logger: logger5,
+  baseDir,
+  outputRoots
+}) {
   if (baseDir !== void 0) {
     logger5.warn(
       "--base-dir is deprecated; use --output-roots instead. It will be removed in a future major release."
@@ -1155,6 +1170,53 @@ async function generateCommand(logger5, options) {
       `Both '--output-roots' and '--base-dir' were provided with differing values; using '--output-roots' (${JSON.stringify(outputRoots)}) and ignoring '--base-dir' (${JSON.stringify(baseDir)}).`
     );
   }
+  return outputRootsResolved;
+}
+var FEATURE_DEBUG_MESSAGES = {
+  ignore: "Generating ignore files...",
+  mcp: "Generating MCP files...",
+  commands: "Generating command files...",
+  subagents: "Generating subagent files...",
+  skills: "Generating skill files...",
+  hooks: "Generating hooks...",
+  rules: "Generating rule files..."
+};
+var FEATURE_DEBUG_ORDER = [
+  "ignore",
+  "mcp",
+  "commands",
+  "subagents",
+  "skills",
+  "hooks",
+  "rules"
+];
+function logFeatureDebugMessages(logger5, features) {
+  for (const feature of FEATURE_DEBUG_ORDER) {
+    if (features.includes(feature)) {
+      logger5.debug(FEATURE_DEBUG_MESSAGES[feature] ?? "");
+    }
+  }
+}
+function buildSummaryParts(result) {
+  const summarySpecs = [
+    { count: result.rulesCount, label: "rules" },
+    { count: result.ignoreCount, label: "ignore files" },
+    { count: result.mcpCount, label: "MCP files" },
+    { count: result.commandsCount, label: "commands" },
+    { count: result.subagentsCount, label: "subagents" },
+    { count: result.skillsCount, label: "skills" },
+    { count: result.hooksCount, label: "hooks" },
+    { count: result.permissionsCount, label: "permissions" }
+  ];
+  const parts = [];
+  for (const { count, label } of summarySpecs) {
+    if (count > 0) parts.push(`${count} ${label}`);
+  }
+  return parts;
+}
+async function generateCommand(logger5, options) {
+  const { baseDir, outputRoots, ...rest } = options;
+  const outputRootsResolved = resolveOutputRoots({ logger: logger5, baseDir, outputRoots });
   const config = await ConfigResolver.resolve(
     { ...rest, outputRoots: outputRootsResolved },
     { logger: logger5 }
@@ -1171,27 +1233,7 @@ async function generateCommand(logger5, options) {
   }
   logger5.debug(`Output roots: ${config.getOutputRoots().join(", ")}`);
   const features = config.getFeatures();
-  if (features.includes("ignore")) {
-    logger5.debug("Generating ignore files...");
-  }
-  if (features.includes("mcp")) {
-    logger5.debug("Generating MCP files...");
-  }
-  if (features.includes("commands")) {
-    logger5.debug("Generating command files...");
-  }
-  if (features.includes("subagents")) {
-    logger5.debug("Generating subagent files...");
-  }
-  if (features.includes("skills")) {
-    logger5.debug("Generating skill files...");
-  }
-  if (features.includes("hooks")) {
-    logger5.debug("Generating hooks...");
-  }
-  if (features.includes("rules")) {
-    logger5.debug("Generating rule files...");
-  }
+  logFeatureDebugMessages(logger5, features);
   const result = await generate({ config, logger: logger5 });
   const totalGenerated = calculateTotalCount(result);
   const featureResults = {
@@ -1244,15 +1286,7 @@ async function generateCommand(logger5, options) {
     logger5.info(`\u2713 All files are up to date (${enabledFeatures})`);
     return;
   }
-  const parts = [];
-  if (result.rulesCount > 0) parts.push(`${result.rulesCount} rules`);
-  if (result.ignoreCount > 0) parts.push(`${result.ignoreCount} ignore files`);
-  if (result.mcpCount > 0) parts.push(`${result.mcpCount} MCP files`);
-  if (result.commandsCount > 0) parts.push(`${result.commandsCount} commands`);
-  if (result.subagentsCount > 0) parts.push(`${result.subagentsCount} subagents`);
-  if (result.skillsCount > 0) parts.push(`${result.skillsCount} skills`);
-  if (result.hooksCount > 0) parts.push(`${result.hooksCount} hooks`);
-  if (result.permissionsCount > 0) parts.push(`${result.permissionsCount} permissions`);
+  const parts = buildSummaryParts(result);
   if (isPreview) {
     logger5.info(`${modePrefix} Would write ${totalGenerated} file(s) total (${parts.join(" + ")})`);
   } else {
@@ -1263,371 +1297,230 @@ async function generateCommand(logger5, options) {
 // src/cli/commands/gitignore.ts
 import { join as join2 } from "path";
 
-// src/cli/commands/gitignore-entries.ts
-var normalizeGitignoreEntryTargets = (target) => {
-  return typeof target === "string" ? [target] : target;
-};
-var GITIGNORE_ENTRY_REGISTRY = [
-  // Common / general
-  {
-    target: "common",
-    feature: "general",
-    entry: `${RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH}/`
-  },
-  { target: "common", feature: "general", entry: ".rulesync/rules/*.local.md" },
-  { target: "common", feature: "general", entry: "rulesync.local.jsonc" },
-  // AGENTS.local.md is placed in common scope (not rovodev-only) so that
-  // local rule files are always gitignored regardless of which targets are enabled.
-  // This prevents accidental commits when a user disables the rovodev target.
-  { target: "common", feature: "general", entry: "**/AGENTS.local.md" },
-  // AGENTS.md
-  {
-    target: ["agentsmd", "amp", "antigravity-cli", "antigravity-ide", "pi", "vibe", "warp"],
-    feature: "rules",
-    entry: "**/AGENTS.md"
-  },
-  { target: "agentsmd", feature: "rules", entry: "**/.agents/" },
-  // Amp
-  // Amp reads project rules from a root `AGENTS.md` (handled by the shared
-  // AGENTS.md entry above) plus `.agents/memories/*.md` non-root rules. Agent
-  // Skills come from the shared `.agents/skills/` project tree. The
-  // `.amp/settings.json` permissions file is a user-managed file (like other
-  // tools' settings.json), so it is intentionally not gitignored.
-  { target: "amp", feature: "rules", entry: "**/.agents/memories/" },
-  { target: "amp", feature: "skills", entry: "**/.agents/skills/" },
-  // Antigravity (IDE + CLI, Antigravity 2.0)
-  // Both targets share the `.agents/` project tree and both write a root
-  // `AGENTS.md` (handled by the shared AGENTS.md entry above). Global-scope
-  // paths (under the home directory, e.g. `~/.gemini/GEMINI.md`) are
-  // intentionally not gitignored.
+// src/types/processor-registry.ts
+var PROCESSOR_REGISTRY = [
   {
-    target: ["antigravity-ide", "antigravity-cli"],
     feature: "rules",
-    entry: "**/.agents/rules/"
-  },
-  { target: "antigravity-cli", feature: "ignore", entry: "**/.geminiignore" },
-  {
-    target: "antigravity-ide",
-    feature: "commands",
-    entry: "**/.agents/workflows/"
+    processor: RulesProcessor,
+    schema: RulesProcessorToolTargetSchema,
+    factory: toolRuleFactories
   },
   {
-    target: ["antigravity-ide", "antigravity-cli"],
-    feature: "skills",
-    entry: "**/.agents/skills/"
+    feature: "ignore",
+    processor: IgnoreProcessor,
+    schema: IgnoreProcessorToolTargetSchema,
+    factory: toolIgnoreFactories
   },
   {
-    target: ["antigravity-ide", "antigravity-cli"],
     feature: "mcp",
-    entry: "**/.agents/mcp_config.json"
-  },
-  {
-    target: ["antigravity-ide", "antigravity-cli"],
-    feature: "hooks",
-    entry: "**/.agents/hooks.json"
-  },
-  // Augment Code
-  { target: "augmentcode", feature: "rules", entry: "**/.augment/rules/" },
-  { target: "augmentcode", feature: "rules", entry: "**/.augment-guidelines" },
-  { target: "augmentcode", feature: "commands", entry: "**/.augment/commands/" },
-  { target: "augmentcode", feature: "subagents", entry: "**/.augment/agents/" },
-  { target: "augmentcode", feature: "skills", entry: "**/.augment/skills/" },
-  { target: "augmentcode", feature: "ignore", entry: "**/.augmentignore" },
-  { target: "augmentcode", feature: "permissions", entry: "**/.augment/settings.json" },
-  { target: "augmentcode", feature: "hooks", entry: "**/.augment/settings.json" },
-  // settings.json is shared with permissions/hooks; re-tag it under `mcp` so
-  // target+feature filtering still resolves the file for MCP runs.
-  { target: "augmentcode", feature: "mcp", entry: "**/.augment/settings.json" },
-  // Claude Code
-  { target: "claudecode", feature: "rules", entry: `**/${CLAUDECODE_RULE_FILE_NAME}` },
-  { target: "claudecode", feature: "rules", entry: `**/${CLAUDECODE_LOCAL_RULE_FILE_NAME}` },
-  {
-    target: "claudecode",
-    feature: "rules",
-    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_RULE_FILE_NAME}`
-  },
-  {
-    target: "claudecode",
-    feature: "rules",
-    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_LOCAL_RULE_FILE_NAME}`
-  },
-  {
-    target: "claudecode",
-    feature: "rules",
-    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_RULES_DIR_NAME}/`
+    processor: McpProcessor,
+    schema: McpProcessorToolTargetSchema,
+    factory: toolMcpFactories
   },
   {
-    target: "claudecode",
     feature: "commands",
-    entry: `**/${toPosixPath(CLAUDECODE_COMMANDS_DIR_PATH)}/`
+    processor: CommandsProcessor,
+    schema: CommandsProcessorToolTargetSchema,
+    factory: toolCommandFactories
   },
   {
-    target: "claudecode",
     feature: "subagents",
-    entry: `**/${toPosixPath(CLAUDECODE_AGENTS_DIR_PATH)}/`
+    processor: SubagentsProcessor,
+    schema: SubagentsProcessorToolTargetSchema,
+    factory: toolSubagentFactories
   },
   {
-    target: "claudecode",
     feature: "skills",
-    entry: `**/${toPosixPath(CLAUDECODE_SKILLS_DIR_PATH)}/`
-  },
-  { target: "claudecode", feature: "mcp", entry: `**/${CLAUDECODE_MCP_FILE_NAME}` },
-  {
-    target: "claudecode",
-    feature: "general",
-    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_MEMORIES_DIR_NAME}/`
+    processor: SkillsProcessor,
+    schema: SkillsProcessorToolTargetSchema,
+    factory: toolSkillFactories
   },
   {
-    target: "claudecode",
-    feature: "general",
-    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_SETTINGS_LOCAL_FILE_NAME}`
-  },
-  { target: "claudecode", feature: "general", entry: `**/${CLAUDECODE_DIR}/*.lock` },
-  // Cline
-  { target: "cline", feature: "rules", entry: "**/.clinerules/" },
-  { target: "cline", feature: "commands", entry: "**/.clinerules/workflows/" },
-  { target: "cline", feature: "ignore", entry: "**/.clineignore" },
-  // Cline reads MCP only from a global settings file
-  // (`~/.cline/data/settings/cline_mcp_settings.json`), which lives under the
-  // home directory and is not gitignored at the project level.
-  { target: "cline", feature: "subagents", entry: "**/.cline/agents/" },
-  { target: "cline", feature: "permissions", entry: "**/.cline/command-permissions.json" },
-  // Codex CLI
-  { target: "codexcli", feature: "ignore", entry: "**/.codexignore" },
-  { target: "codexcli", feature: "skills", entry: "**/.agents/skills/" },
-  { target: "codexcli", feature: "subagents", entry: "**/.codex/agents/" },
-  { target: "codexcli", feature: "general", entry: "**/.codex/memories/" },
-  { target: "codexcli", feature: "general", entry: "**/.codex/config.toml" },
-  { target: "codexcli", feature: "hooks", entry: "**/.codex/hooks.json" },
-  // Cursor
-  { target: "cursor", feature: "rules", entry: "**/.cursor/" },
-  { target: "cursor", feature: "ignore", entry: "**/.cursorignore" },
-  // .cursor/cli.json (project) and .cursor/cli-config.json (global) are
-  // already covered by the broader **/.cursor/ entry above; the additional
-  // `permissions` and `hooks` tags below register the same prefix under the
-  // matching feature so target+feature filtering still resolves correctly.
-  { target: "cursor", feature: "permissions", entry: "**/.cursor/" },
-  { target: "cursor", feature: "hooks", entry: "**/.cursor/" },
-  // deepagents-cli
-  // All rule content is folded into the single `.deepagents/AGENTS.md`; there is
-  // no `.deepagents/memories/` directory.
-  { target: "deepagents", feature: "rules", entry: "**/.deepagents/AGENTS.md" },
-  { target: "deepagents", feature: "mcp", entry: "**/.deepagents/.mcp.json" },
-  { target: "deepagents", feature: "skills", entry: "**/.deepagents/skills/" },
-  {
-    target: "deepagents",
-    feature: "subagents",
-    entry: "**/.deepagents/agents/"
-  },
-  {
-    target: "deepagents",
     feature: "hooks",
-    entry: "**/.deepagents/hooks.json"
-  },
-  // Factory Droid
-  { target: "factorydroid", feature: "rules", entry: "**/.factory/rules/" },
-  {
-    target: "factorydroid",
-    feature: "commands",
-    entry: "**/.factory/commands/"
+    processor: HooksProcessor,
+    schema: HooksProcessorToolTargetSchema,
+    factory: toolHooksFactories
   },
   {
-    target: "factorydroid",
-    feature: "subagents",
-    entry: "**/.factory/droids/"
-  },
-  { target: "factorydroid", feature: "skills", entry: "**/.factory/skills/" },
-  { target: "factorydroid", feature: "mcp", entry: "**/.factory/mcp.json" },
-  {
-    target: "factorydroid",
-    feature: "hooks",
-    entry: "**/.factory/hooks.json"
-  },
-  // Gemini CLI
-  { target: "geminicli", feature: "rules", entry: "**/GEMINI.md" },
-  { target: "geminicli", feature: "commands", entry: "**/.gemini/commands/" },
-  { target: "geminicli", feature: "subagents", entry: "**/.gemini/agents/" },
-  { target: "geminicli", feature: "skills", entry: "**/.gemini/skills/" },
-  { target: "geminicli", feature: "ignore", entry: "**/.geminiignore" },
-  { target: "geminicli", feature: "general", entry: "**/.gemini/memories/" },
-  // Goose
-  { target: "goose", feature: "rules", entry: "**/.goosehints" },
-  { target: "goose", feature: "rules", entry: "**/.goose/" },
-  { target: "goose", feature: "ignore", entry: "**/.gooseignore" },
-  // Goose recipes: commands map to top-level recipes (`.goose/recipes/*.yaml`)
-  // and subagents to sub-recipes (`.goose/recipes/subagents/*.yaml`). These are
-  // already covered by the broad `**/.goose/` rules entry above, but tagging
-  // them per-feature keeps coverage correct under feature-filtered gitignore.
-  { target: "goose", feature: "commands", entry: "**/.goose/recipes/" },
-  { target: "goose", feature: "subagents", entry: "**/.goose/recipes/subagents/" },
-  // Goose lifecycle hooks plugin (.agents/plugins/<name>/hooks/hooks.json)
-  { target: "goose", feature: "hooks", entry: "**/.agents/plugins/" },
-  // Goose reads MCP "extensions" only from the global user config
-  // (`~/.config/goose/config.yaml`), which lives under the home directory and is
-  // not gitignored at the project level (mirrors Cline's global-only MCP).
-  // Grok Build
-  { target: "grokcli", feature: "general", entry: "**/.grok/config.toml" },
-  // GitHub Copilot
+    feature: "permissions",
+    processor: PermissionsProcessor,
+    schema: PermissionsProcessorToolTargetSchema,
+    factory: toolPermissionsFactories
+  }
+];
+var getProcessorRegistryEntry = (feature) => {
+  const entry = PROCESSOR_REGISTRY.find((e) => e.feature === feature);
+  if (!entry) {
+    throw new Error(`No processor registered for feature: ${feature}`);
+  }
+  return entry;
+};
+
+// src/cli/commands/gitignore-derive.ts
+var TARGETS_NOT_DERIVED = /* @__PURE__ */ new Set([
+  "agentsskills",
+  "antigravity",
+  "augmentcode-legacy",
+  "claudecode-legacy"
+]);
+var DERIVED_PATHS_NOT_GITIGNORED = /* @__PURE__ */ new Set([
+  "**/.amp/settings.json",
+  "**/.amp/settings.jsonc",
+  "**/.antigravity/settings.json",
+  "**/.claude/settings.json",
+  "**/.claude/settings.local.json",
+  "**/.factory/settings.json",
+  "**/.gemini/settings.json",
+  "**/.zed/settings.json",
+  "**/.warp/settings.toml",
+  "**/kilo.json",
+  "**/kilo.jsonc",
+  "**/opencode.json"
+]);
+var toPosix = (path2) => path2.replace(/\\/g, "/");
+var dirToGlob = (relativeDirPath) => `**/${toPosix(relativeDirPath).replace(/\/$/, "")}/`;
+var fileToGlob = (relativeDirPath, relativeFilePath) => {
+  const hasDir = relativeDirPath && relativeDirPath !== ".";
+  return `**/${toPosix(hasDir ? `${relativeDirPath}/${relativeFilePath}` : relativeFilePath)}`;
+};
+var supportsProject = (factory) => {
+  if (typeof factory !== "object" || factory === null || !("meta" in factory)) return true;
+  const meta = factory.meta;
+  return meta?.supportsProject !== false;
+};
+var getProjectPaths = (factory) => factory.class.getSettablePaths({ global: false });
+var pushEntry = (entries, target, feature, entry) => {
+  if (DERIVED_PATHS_NOT_GITIGNORED.has(entry)) return;
+  entries.push({ target, feature, entry });
+};
+var deriveDirEntries = (factories, feature) => {
+  const entries = [];
+  for (const [target, factory] of factories) {
+    if (TARGETS_NOT_DERIVED.has(target)) continue;
+    if (!supportsProject(factory)) continue;
+    const paths = getProjectPaths(factory);
+    const dir = paths.relativeDirPath;
+    if (!dir || dir === ".") continue;
+    pushEntry(entries, target, feature, dirToGlob(dir));
+  }
+  return entries;
+};
+var deriveFileEntries = (factories, feature) => {
+  const entries = [];
+  for (const [target, factory] of factories) {
+    if (TARGETS_NOT_DERIVED.has(target)) continue;
+    if (!supportsProject(factory)) continue;
+    const paths = getProjectPaths(factory);
+    if (!paths.relativeFilePath) continue;
+    pushEntry(entries, target, feature, fileToGlob(paths.relativeDirPath, paths.relativeFilePath));
+  }
+  return entries;
+};
+var deriveRulesEntries = () => {
+  const entries = [];
+  const factories = getProcessorRegistryEntry("rules").factory;
+  for (const [target, factory] of factories) {
+    if (TARGETS_NOT_DERIVED.has(target)) continue;
+    const paths = getProjectPaths(factory);
+    for (const root of [paths.root, ...paths.alternativeRoots ?? []]) {
+      if (root)
+        pushEntry(
+          entries,
+          target,
+          "rules",
+          fileToGlob(root.relativeDirPath, root.relativeFilePath)
+        );
+    }
+    const nonRootDir = paths.nonRoot?.relativeDirPath;
+    if (nonRootDir && nonRootDir !== ".") {
+      pushEntry(entries, target, "rules", dirToGlob(nonRootDir));
+    }
+  }
+  return entries;
+};
+var DIR_FEATURES = /* @__PURE__ */ new Set(["commands", "skills", "subagents"]);
+var FILE_FEATURES = /* @__PURE__ */ new Set(["mcp", "hooks", "permissions", "ignore"]);
+var deriveFeatureGitignoreEntries = (feature) => {
+  if (feature === "rules") return deriveRulesEntries();
+  const factory = getProcessorRegistryEntry(feature).factory;
+  if (DIR_FEATURES.has(feature)) return deriveDirEntries(factory, feature);
+  if (FILE_FEATURES.has(feature)) return deriveFileEntries(factory, feature);
+  return [];
+};
+var DERIVED_FEATURES = [
+  "rules",
+  "commands",
+  "skills",
+  "subagents",
+  "mcp",
+  "hooks",
+  "permissions",
+  "ignore"
+];
+var deriveAllGitignoreEntries = () => DERIVED_FEATURES.flatMap((feature) => deriveFeatureGitignoreEntries(feature));
+
+// src/cli/commands/gitignore-entries.ts
+var normalizeGitignoreEntryTargets = (target) => {
+  return typeof target === "string" ? [target] : target;
+};
+var HAND_MAINTAINED_GITIGNORE_ENTRIES = [
+  // rulesync's own meta files (common scope).
   {
-    target: ["copilot", "copilotcli"],
-    feature: "rules",
-    entry: "**/.github/copilot-instructions.md"
+    target: "common",
+    feature: "general",
+    entry: `${RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH}/`
   },
+  { target: "common", feature: "general", entry: ".rulesync/rules/*.local.md" },
+  { target: "common", feature: "general", entry: "rulesync.local.jsonc" },
+  // AGENTS.local.md is placed in common scope (not rovodev-only) so that
+  // local rule files are always gitignored regardless of which targets are enabled.
+  { target: "common", feature: "general", entry: "**/AGENTS.local.md" },
+  // Local-root rule files: materialized outside getSettablePaths.
+  { target: "claudecode", feature: "rules", entry: `**/${CLAUDECODE_LOCAL_RULE_FILE_NAME}` },
   {
-    target: ["copilot", "copilotcli"],
+    target: "claudecode",
     feature: "rules",
-    entry: "**/.github/instructions/"
-  },
-  { target: "copilot", feature: "commands", entry: "**/.github/prompts/" },
-  { target: "copilot", feature: "subagents", entry: "**/.github/agents/" },
-  // Copilot CLI shares the project `.github/skills/` location with the Copilot
-  // IDE target; its personal skills live under `~/.copilot/skills/` (home dir,
-  // not gitignored at the project level).
-  { target: ["copilot", "copilotcli"], feature: "skills", entry: "**/.github/skills/" },
-  { target: "copilot", feature: "hooks", entry: "**/.github/hooks/" },
-  { target: "copilot", feature: "mcp", entry: "**/.vscode/mcp.json" },
-  // GitHub Copilot CLI
-  {
-    target: "copilotcli",
-    feature: "mcp",
-    entry: "**/.copilot/mcp-config.json"
-  },
-  // Project: <project>/.github/agents/*.agent.md
-  // Global: ~/.copilot/agents/
-  { target: "copilotcli", feature: "subagents", entry: "**/.github/agents/" },
-  { target: "copilotcli", feature: "subagents", entry: "**/.copilot/agents/" },
-  // Project: <project>/.github/hooks/copilotcli-hooks.json
-  // Global: ~/.copilot/hooks/copilot-hooks.json (rulesync convention pending
-  //         official documentation of a global hooks location)
-  { target: "copilotcli", feature: "hooks", entry: "**/.github/hooks/" },
-  { target: "copilotcli", feature: "hooks", entry: "**/.copilot/hooks/" },
-  // Junie
-  { target: "junie", feature: "rules", entry: "**/.junie/guidelines.md" },
-  { target: "junie", feature: "mcp", entry: "**/.junie/mcp/mcp.json" },
-  { target: "junie", feature: "skills", entry: "**/.junie/skills/" },
-  { target: "junie", feature: "subagents", entry: "**/.junie/agents/" },
-  // Kilo Code
-  { target: "kilo", feature: "rules", entry: "**/.kilo/rules/" },
-  { target: "kilo", feature: "skills", entry: "**/.kilo/skills/" },
-  { target: "kilo", feature: "commands", entry: "**/.kilo/workflows/" },
-  { target: "kilo", feature: "mcp", entry: "**/.kilo/mcp.json" },
-  { target: "kilo", feature: "ignore", entry: "**/.kilocodeignore" },
-  // No `**/kilo.jsonc` entry: structurally identical to `opencode.jsonc` (no
-  // entry). The Kilo translator preserves non-permissions Kilo settings on
-  // round-trip, so the file is intended to be checked in by the user — adding
-  // `**/kilo.jsonc` would be too aggressive.
-  // Kiro
-  { target: "kiro", feature: "rules", entry: "**/.kiro/steering/" },
-  { target: "kiro", feature: "commands", entry: "**/.kiro/prompts/" },
-  { target: "kiro", feature: "skills", entry: "**/.kiro/skills/" },
-  { target: "kiro", feature: "subagents", entry: "**/.kiro/agents/" },
-  { target: "kiro", feature: "mcp", entry: "**/.kiro/settings/mcp.json" },
-  { target: "kiro", feature: "ignore", entry: "**/.aiignore" },
-  // Kiro IDE and CLI write to the same `.kiro/` tree as the legacy `kiro` alias.
-  // (Kiro IDE subagents are Markdown under `.kiro/agents/`, the CLI's are JSON —
-  // both covered by the shared `**/.kiro/agents/` entry.)
-  { target: ["kiro-cli", "kiro-ide"], feature: "rules", entry: "**/.kiro/steering/" },
-  { target: ["kiro-cli", "kiro-ide"], feature: "commands", entry: "**/.kiro/prompts/" },
-  { target: ["kiro-cli", "kiro-ide"], feature: "skills", entry: "**/.kiro/skills/" },
-  { target: ["kiro-cli", "kiro-ide"], feature: "subagents", entry: "**/.kiro/agents/" },
-  { target: ["kiro-cli", "kiro-ide"], feature: "mcp", entry: "**/.kiro/settings/mcp.json" },
-  { target: ["kiro-cli", "kiro-ide"], feature: "ignore", entry: "**/.aiignore" },
-  // Keep this after ignore entries like "**/.aiignore" so the exception remains effective.
-  { target: "common", feature: "general", entry: "!.rulesync/.aiignore" },
-  // OpenCode
-  { target: "opencode", feature: "commands", entry: "**/.opencode/commands/" },
-  { target: "opencode", feature: "subagents", entry: "**/.opencode/agents/" },
-  { target: "opencode", feature: "skills", entry: "**/.opencode/skills/" },
-  { target: "opencode", feature: "mcp", entry: "**/.opencode/plugins/" },
-  { target: "opencode", feature: "general", entry: "**/.opencode/memories/" },
-  {
-    target: "opencode",
-    feature: "general",
-    entry: "**/.opencode/package-lock.json"
+    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_LOCAL_RULE_FILE_NAME}`
   },
-  // Pi Coding Agent
-  { target: "pi", feature: "rules", entry: "**/.agents/memories/" },
-  { target: "pi", feature: "commands", entry: "**/.pi/prompts/" },
-  { target: "pi", feature: "skills", entry: "**/.pi/skills/" },
-  // Qwen Code
-  { target: "qwencode", feature: "rules", entry: "**/QWEN.md" },
-  { target: "qwencode", feature: "commands", entry: "**/.qwen/commands/" },
-  { target: "qwencode", feature: "subagents", entry: "**/.qwen/agents/" },
-  { target: "qwencode", feature: "skills", entry: "**/.qwen/skills/" },
-  { target: "qwencode", feature: "ignore", entry: "**/.qwenignore" },
-  { target: "qwencode", feature: "general", entry: "**/.qwen/memories/" },
-  // mcp + hooks both write to `.qwen/settings.json`, shared with permissions.
-  { target: "qwencode", feature: "permissions", entry: "**/.qwen/settings.json" },
-  // Replit
-  { target: "replit", feature: "rules", entry: "**/replit.md" },
-  // Roo
-  { target: "roo", feature: "rules", entry: "**/.roo/rules/" },
-  { target: "roo", feature: "skills", entry: "**/.roo/skills/" },
-  { target: "roo", feature: "ignore", entry: "**/.rooignore" },
-  { target: "roo", feature: "mcp", entry: "**/.roo/mcp.json" },
-  { target: "roo", feature: "subagents", entry: "**/.roomodes" },
-  // Rovodev
+  // Third-party tool by-products rulesync gitignores but never writes itself.
+  { target: "claudecode", feature: "general", entry: `**/${CLAUDECODE_DIR}/*.lock` },
   {
-    target: "rovodev",
+    target: "claudecode",
     feature: "general",
-    entry: "**/.rovodev/AGENTS.md"
+    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_SETTINGS_LOCAL_FILE_NAME}`
   },
-  { target: "rovodev", feature: "subagents", entry: "**/.rovodev/subagents/" },
-  { target: "rovodev", feature: "skills", entry: "**/.rovodev/skills/" },
   {
-    target: "rovodev",
+    target: "claudecode",
     feature: "general",
-    entry: "**/.rovodev/.rulesync/"
+    entry: `**/${CLAUDECODE_DIR}/${CLAUDECODE_MEMORIES_DIR_NAME}/`
   },
-  { target: "rovodev", feature: "skills", entry: "**/.agents/skills/" },
-  // TAKT
-  // Each rulesync feature maps one-to-one onto a TAKT facet directory.
-  { target: "takt", feature: "rules", entry: "**/.takt/facets/policies/" },
-  { target: "takt", feature: "skills", entry: "**/.takt/facets/knowledge/" },
-  { target: "takt", feature: "subagents", entry: "**/.takt/facets/personas/" },
-  { target: "takt", feature: "commands", entry: "**/.takt/facets/instructions/" },
+  { target: "opencode", feature: "general", entry: "**/.opencode/package-lock.json" },
+  { target: "rovodev", feature: "general", entry: "**/.rovodev/.rulesync/" },
   { target: "takt", feature: "general", entry: "**/.takt/runs/" },
   { target: "takt", feature: "general", entry: "**/.takt/tasks/" },
   { target: "takt", feature: "general", entry: "**/.takt/.cache/" },
   { target: "takt", feature: "general", entry: "**/.takt/config.yaml" },
-  // Devin (Devin Desktop). Since the rebrand (v3.0.12, 2026-06-02), project
-  // rules/workflows/skills live under `.devin/`; MCP and hooks keep their
-  // `.devin/` paths and the global skills path is unchanged.
-  { target: "devin", feature: "rules", entry: "**/.devin/rules/" },
-  { target: "devin", feature: "commands", entry: "**/.devin/workflows/" },
-  { target: "devin", feature: "ignore", entry: "**/.devinignore" },
-  { target: "devin", feature: "mcp", entry: "**/.windsurf/mcp_config.json" },
-  { target: "devin", feature: "hooks", entry: "**/.windsurf/hooks.json" },
-  { target: "devin", feature: "skills", entry: "**/.devin/skills/" },
+  // Augment Code's legacy single-file rules path: accepted on import but never
+  // generated (so not in getSettablePaths), gitignored as a convenience.
+  { target: "augmentcode", feature: "rules", entry: "**/.augment-guidelines" },
+  // Shared trees and global-scope outputs not produced via project getSettablePaths.
+  { target: "rovodev", feature: "skills", entry: "**/.agents/skills/" },
   { target: "devin", feature: "skills", entry: "**/.codeium/windsurf/skills/" },
-  // Devin Local custom subagent profiles: `.devin/agents/<name>/AGENT.md`
-  // (project). The global path `~/.config/devin/agents/` lives under the home
-  // directory and is not gitignored at the project level.
-  { target: "devin", feature: "subagents", entry: "**/.devin/agents/" },
-  // Vibe
-  { target: "vibe", feature: "ignore", entry: "**/.vibeignore" },
-  { target: "vibe", feature: "skills", entry: "**/.vibe/skills/" },
-  { target: "vibe", feature: "subagents", entry: "**/.vibe/agents/" },
-  { target: "vibe", feature: "mcp", entry: "**/.vibe/config.toml" },
-  { target: "vibe", feature: "permissions", entry: "**/.vibe/config.toml" },
-  // Experimental hooks live in `.vibe/hooks.toml`; the `enable_experimental_hooks`
-  // flag is merged into the shared `.vibe/config.toml` (already covered above).
-  { target: "vibe", feature: "hooks", entry: "**/.vibe/hooks.toml" },
-  { target: "vibe", feature: "hooks", entry: "**/.vibe/config.toml" },
-  // Warp
-  // Warp reads project rules only from the root `AGENTS.md` (handled by the
-  // shared AGENTS.md entry above); it does not read `.warp/memories/`, so no
-  // rules entry under `.warp/` is emitted.
-  { target: "warp", feature: "mcp", entry: "**/.warp/.mcp.json" },
-  { target: "warp", feature: "skills", entry: "**/.warp/skills/" },
-  // Zed
-  // `.rules` is the project rules file. `.agents/skills/` is shared with the
-  // antigravity targets (already registered above); re-tagging it for `zed`
-  // ensures target-filtered gitignore runs still include it.
-  // No entry for `.zed/settings.json` (MCP / ignore): it is a user-managed
-  // file, like other tools' settings.json, so it is intentionally not ignored.
-  { target: "zed", feature: "rules", entry: "**/.rules" },
-  { target: "zed", feature: "skills", entry: "**/.agents/skills/" }
+  { target: "copilotcli", feature: "subagents", entry: "**/.copilot/agents/" },
+  { target: "copilotcli", feature: "mcp", entry: "**/.copilot/mcp-config.json" },
+  { target: "copilotcli", feature: "hooks", entry: "**/.copilot/hooks/" },
+  { target: "deepagents", feature: "hooks", entry: "**/.deepagents/hooks.json" },
+  // Roo aggregates subagents into a single `.roomodes` file (no settable path).
+  { target: "roo", feature: "subagents", entry: "**/.roomodes" },
+  // codexcli has no ignore processor; its `.codexignore` is a ghost entry.
+  { target: "codexcli", feature: "ignore", entry: "**/.codexignore" }
+];
+var GITIGNORE_ENTRY_REGISTRY = [
+  ...HAND_MAINTAINED_GITIGNORE_ENTRIES,
+  // Every entry a tool actually emits, derived from its getSettablePaths.
+  ...deriveAllGitignoreEntries(),
+  // Keep this after ignore entries like Junie's "**/.aiignore" so the exception remains effective.
+  { target: "common", feature: "general", entry: "!.rulesync/.aiignore" }
 ];
 var ALL_GITIGNORE_ENTRIES = (() => {
   const seen = /* @__PURE__ */ new Set();
@@ -2340,7 +2233,7 @@ function findApmLockDependency(lock, repoUrl) {
 
 // src/lib/apm/apm-manifest.ts
 import { join as join5 } from "path";
-import { dump as dump2, load as load2 } from "js-yaml";
+import { load as load2 } from "js-yaml";
 import { optional as optional2, z as z5 } from "zod/mini";
 var APM_MANIFEST_FILE_NAME = "apm.yml";
 var ApmObjectDependencySchema = z5.looseObject({
@@ -2548,34 +2441,7 @@ async function installApm(params) {
   }
   const existingLock = await readApmLock(projectRoot);
   if (options.frozen) {
-    if (!existingLock) {
-      throw new Error(
-        "Frozen install failed: rulesync-apm.lock.yaml is missing. Run 'rulesync install --mode apm' to create it."
-      );
-    }
-    const missing = manifest.dependencies.filter(
-      (dep) => !findApmLockDependency(existingLock, canonicalRepoUrl(dep))
-    );
-    if (missing.length > 0) {
-      const names = missing.map((d) => d.gitUrl).join(", ");
-      throw new Error(
-        `Frozen install failed: rulesync-apm.lock.yaml is missing entries for: ${names}. Run 'rulesync install --mode apm' to update the lockfile.`
-      );
-    }
-    const drifted = manifest.dependencies.filter((dep) => {
-      if (dep.ref === void 0) return false;
-      const locked = findApmLockDependency(existingLock, canonicalRepoUrl(dep));
-      return locked?.resolved_ref !== void 0 && locked.resolved_ref !== dep.ref;
-    });
-    if (drifted.length > 0) {
-      const names = drifted.map((d) => {
-        const locked = findApmLockDependency(existingLock, canonicalRepoUrl(d));
-        return `${d.gitUrl} (manifest=${d.ref}, lock=${locked?.resolved_ref})`;
-      }).join(", ");
-      throw new Error(
-        `Frozen install failed: manifest ref does not match rulesync-apm.lock.yaml for: ${names}. Run 'rulesync install --mode apm' to update the lockfile.`
-      );
-    }
+    assertFrozenLockCoversManifest({ existingLock, dependencies: manifest.dependencies });
   }
   const token = GitHubClient.resolveToken(options.token);
   const client = new GitHubClient({ token });
@@ -2630,30 +2496,7 @@ async function installApm(params) {
     }
   }
   if (existingLock) {
-    const newDeployedFiles = new Set(newLock.dependencies.flatMap((d) => d.deployed_files));
-    const toDelete = [];
-    for (const prev of existingLock.dependencies) {
-      for (const deployed of prev.deployed_files) {
-        if (!newDeployedFiles.has(deployed)) {
-          toDelete.push(deployed);
-        }
-      }
-    }
-    for (const relativePath of toDelete) {
-      if (posix2.isAbsolute(relativePath) || relativePath.split(/[/\\]/).includes("..")) {
-        logger5.warn(`Refusing to remove stale apm file with suspicious path: "${relativePath}".`);
-        continue;
-      }
-      try {
-        checkPathTraversal({ relativePath, intendedRootDir: projectRoot });
-      } catch {
-        logger5.warn(`Refusing to remove stale apm file outside projectRoot: "${relativePath}".`);
-        continue;
-      }
-      const absolute = join6(projectRoot, relativePath);
-      await removeFile(absolute);
-      logger5.debug(`Removed stale apm file: ${relativePath}`);
-    }
+    await removeStaleApmFiles({ existingLock, newLock, projectRoot, logger: logger5 });
   }
   if (!frozen) {
     newLock.generated_at = (/* @__PURE__ */ new Date()).toISOString();
@@ -2672,6 +2515,64 @@ async function installApm(params) {
     failedDependencyCount: failedCount
   };
 }
+function assertFrozenLockCoversManifest(params) {
+  const { existingLock, dependencies } = params;
+  if (!existingLock) {
+    throw new Error(
+      "Frozen install failed: rulesync-apm.lock.yaml is missing. Run 'rulesync install --mode apm' to create it."
+    );
+  }
+  const missing = dependencies.filter(
+    (dep) => !findApmLockDependency(existingLock, canonicalRepoUrl(dep))
+  );
+  if (missing.length > 0) {
+    const names = missing.map((d) => d.gitUrl).join(", ");
+    throw new Error(
+      `Frozen install failed: rulesync-apm.lock.yaml is missing entries for: ${names}. Run 'rulesync install --mode apm' to update the lockfile.`
+    );
+  }
+  const drifted = dependencies.filter((dep) => {
+    if (dep.ref === void 0) return false;
+    const locked = findApmLockDependency(existingLock, canonicalRepoUrl(dep));
+    return locked?.resolved_ref !== void 0 && locked.resolved_ref !== dep.ref;
+  });
+  if (drifted.length > 0) {
+    const names = drifted.map((d) => {
+      const locked = findApmLockDependency(existingLock, canonicalRepoUrl(d));
+      return `${d.gitUrl} (manifest=${d.ref}, lock=${locked?.resolved_ref})`;
+    }).join(", ");
+    throw new Error(
+      `Frozen install failed: manifest ref does not match rulesync-apm.lock.yaml for: ${names}. Run 'rulesync install --mode apm' to update the lockfile.`
+    );
+  }
+}
+async function removeStaleApmFiles(params) {
+  const { existingLock, newLock, projectRoot, logger: logger5 } = params;
+  const newDeployedFiles = new Set(newLock.dependencies.flatMap((d) => d.deployed_files));
+  const toDelete = [];
+  for (const prev of existingLock.dependencies) {
+    for (const deployed of prev.deployed_files) {
+      if (!newDeployedFiles.has(deployed)) {
+        toDelete.push(deployed);
+      }
+    }
+  }
+  for (const relativePath of toDelete) {
+    if (posix2.isAbsolute(relativePath) || relativePath.split(/[/\\]/).includes("..")) {
+      logger5.warn(`Refusing to remove stale apm file with suspicious path: "${relativePath}".`);
+      continue;
+    }
+    try {
+      checkPathTraversal({ relativePath, intendedRootDir: projectRoot });
+    } catch {
+      logger5.warn(`Refusing to remove stale apm file outside projectRoot: "${relativePath}".`);
+      continue;
+    }
+    const absolute = join6(projectRoot, relativePath);
+    await removeFile(absolute);
+    logger5.debug(`Removed stale apm file: ${relativePath}`);
+  }
+}
 async function installDependency(params) {
   const { dep, client, semaphore, projectRoot, existingLock, frozen, update, logger: logger5 } = params;
   const repoUrl = canonicalRepoUrl(dep);
@@ -2700,58 +2601,25 @@ async function installDependency(params) {
       logger: logger5
     });
     if (files.length === 0) continue;
-    for (const file of files) {
-      if (file.size > MAX_FILE_SIZE) {
-        logger5.warn(
-          `Skipping "${file.path}" from ${repoUrl}: ${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
-        );
-        continue;
-      }
-      const relativeToBase = posix2.relative(remoteBase, toPosixPath(file.path));
-      if (!relativeToBase || relativeToBase.startsWith("..") || posix2.isAbsolute(relativeToBase)) {
-        logger5.warn(
-          `Skipping "${file.path}" from ${repoUrl}: resolved outside of "${remoteBase}".`
-        );
-        continue;
-      }
-      const deployRelative = toPosixPath(join6(primitive.deployDir, relativeToBase));
-      checkPathTraversal({
-        relativePath: deployRelative,
-        intendedRootDir: projectRoot
-      });
-      const content = await withSemaphore(
-        semaphore,
-        () => client.getFileContent(dep.owner, dep.repo, file.path, resolvedSha)
-      );
-      const byteLength = Buffer.byteLength(content, "utf8");
-      if (byteLength > MAX_FILE_SIZE) {
-        logger5.warn(
-          `Skipping "${file.path}" from ${repoUrl}: fetched ${(byteLength / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
-        );
-        continue;
-      }
-      deployed.push({ path: deployRelative, content });
-      if (!frozen) {
-        await writeFileContent(join6(projectRoot, deployRelative), content);
-      }
-    }
+    await collectPrimitiveDeployments({
+      dep,
+      client,
+      semaphore,
+      projectRoot,
+      primitive,
+      remoteBase,
+      files,
+      resolvedSha,
+      repoUrl,
+      frozen,
+      deployed,
+      logger: logger5
+    });
   }
   deployed.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
   const deployedFiles = deployed.map((d) => d.path);
   const contentHash = computeContentHash(deployed);
-  if (frozen && locked?.content_hash) {
-    if (RULESYNC_CONTENT_HASH_REGEX.test(locked.content_hash)) {
-      if (locked.content_hash !== contentHash) {
-        throw new Error(
-          `content_hash mismatch for ${repoUrl}: lock=${locked.content_hash} computed=${contentHash}. Refuse to trust the deployment under --frozen.`
-        );
-      }
-    } else {
-      logger5.debug(
-        `Skipping content_hash integrity check for ${repoUrl}: recorded hash "${locked.content_hash}" was not written by rulesync.`
-      );
-    }
-  }
+  assertFrozenContentHashMatches({ frozen, locked, contentHash, repoUrl, logger: logger5 });
   if (frozen) {
     for (const { path: deployRelative, content } of deployed) {
       await writeFileContent(join6(projectRoot, deployRelative), content);
@@ -2772,20 +2640,85 @@ async function installDependency(params) {
   logger5.info(`Installed ${deployedFiles.length} file(s) from ${repoUrl}@${shortSha(resolvedSha)}`);
   return { lockEntry, deployedFiles };
 }
-function computeContentHash(files) {
-  const hash = createHash("sha256");
-  for (const { path: path2, content } of files) {
-    hash.update(path2);
-    hash.update("\0");
-    hash.update(content);
-    hash.update("\0");
-  }
-  return `sha256:${hash.digest("hex")}`;
-}
-async function listPrimitiveFiles(params) {
-  const { client, semaphore, owner, repo, ref, remoteBase, logger: logger5 } = params;
-  try {
-    return await listDirectoryRecursive({
+async function collectPrimitiveDeployments(params) {
+  const {
+    dep,
+    client,
+    semaphore,
+    projectRoot,
+    primitive,
+    remoteBase,
+    files,
+    resolvedSha,
+    repoUrl,
+    frozen,
+    deployed,
+    logger: logger5
+  } = params;
+  for (const file of files) {
+    if (file.size > MAX_FILE_SIZE) {
+      logger5.warn(
+        `Skipping "${file.path}" from ${repoUrl}: ${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
+      );
+      continue;
+    }
+    const relativeToBase = posix2.relative(remoteBase, toPosixPath(file.path));
+    if (!relativeToBase || relativeToBase.startsWith("..") || posix2.isAbsolute(relativeToBase)) {
+      logger5.warn(`Skipping "${file.path}" from ${repoUrl}: resolved outside of "${remoteBase}".`);
+      continue;
+    }
+    const deployRelative = toPosixPath(join6(primitive.deployDir, relativeToBase));
+    checkPathTraversal({
+      relativePath: deployRelative,
+      intendedRootDir: projectRoot
+    });
+    const content = await withSemaphore(
+      semaphore,
+      () => client.getFileContent(dep.owner, dep.repo, file.path, resolvedSha)
+    );
+    const byteLength = Buffer.byteLength(content, "utf8");
+    if (byteLength > MAX_FILE_SIZE) {
+      logger5.warn(
+        `Skipping "${file.path}" from ${repoUrl}: fetched ${(byteLength / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
+      );
+      continue;
+    }
+    deployed.push({ path: deployRelative, content });
+    if (!frozen) {
+      await writeFileContent(join6(projectRoot, deployRelative), content);
+    }
+  }
+}
+function assertFrozenContentHashMatches(params) {
+  const { frozen, locked, contentHash, repoUrl, logger: logger5 } = params;
+  if (frozen && locked?.content_hash) {
+    if (RULESYNC_CONTENT_HASH_REGEX.test(locked.content_hash)) {
+      if (locked.content_hash !== contentHash) {
+        throw new Error(
+          `content_hash mismatch for ${repoUrl}: lock=${locked.content_hash} computed=${contentHash}. Refuse to trust the deployment under --frozen.`
+        );
+      }
+    } else {
+      logger5.debug(
+        `Skipping content_hash integrity check for ${repoUrl}: recorded hash "${locked.content_hash}" was not written by rulesync.`
+      );
+    }
+  }
+}
+function computeContentHash(files) {
+  const hash = createHash("sha256");
+  for (const { path: path2, content } of files) {
+    hash.update(path2);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+async function listPrimitiveFiles(params) {
+  const { client, semaphore, owner, repo, ref, remoteBase, logger: logger5 } = params;
+  try {
+    return await listDirectoryRecursive({
       client,
       owner,
       repo,
@@ -2814,7 +2747,7 @@ import { basename, join as join9, posix as posix3 } from "path";
 import { Semaphore as Semaphore3 } from "es-toolkit/promise";
 
 // src/lib/gh/gh-frontmatter.ts
-import { dump as dump3, load as load3 } from "js-yaml";
+import { dump as dump2, load as load3 } from "js-yaml";
 var FRONTMATTER_FENCE = "---";
 function injectSourceMetadata(params) {
   const { content, source, repository, ref } = params;
@@ -2829,7 +2762,7 @@ function injectSourceMetadata(params) {
   } else if (content === FRONTMATTER_FENCE) {
     openFenceLen = 3;
   } else {
-    const yaml2 = dump3(provenance, { noRefs: true, lineWidth: -1, sortKeys: false });
+    const yaml2 = dump2(provenance, { noRefs: true, lineWidth: -1, sortKeys: false });
     return `${FRONTMATTER_FENCE}
 ${yaml2}${FRONTMATTER_FENCE}
 ${content}`;
@@ -2856,7 +2789,7 @@ ${content}`;
     throw new Error("invalid frontmatter");
   }
   if (loaded === null || loaded === void 0) {
-    const yaml2 = dump3(provenance, { noRefs: true, lineWidth: -1, sortKeys: false });
+    const yaml2 = dump2(provenance, { noRefs: true, lineWidth: -1, sortKeys: false });
     return `${FRONTMATTER_FENCE}
 ${yaml2}${FRONTMATTER_FENCE}
 ${rest}`;
@@ -2869,7 +2802,7 @@ ${rest}`;
     ...existing,
     ...provenance
   };
-  const yaml = dump3(merged, { noRefs: true, lineWidth: -1, sortKeys: false });
+  const yaml = dump2(merged, { noRefs: true, lineWidth: -1, sortKeys: false });
   return `${FRONTMATTER_FENCE}
 ${yaml}${FRONTMATTER_FENCE}
 ${rest}`;
@@ -2877,7 +2810,7 @@ ${rest}`;
 
 // src/lib/gh/gh-lock.ts
 import { join as join7 } from "path";
-import { dump as dump4, load as load4 } from "js-yaml";
+import { dump as dump3, load as load4 } from "js-yaml";
 import { optional as optional3, refine as refine2, z as z6 } from "zod/mini";
 var GH_LOCKFILE_FILE_NAME = "rulesync-gh.lock.yaml";
 var GH_LOCKFILE_VERSION = "1";
@@ -2949,7 +2882,7 @@ async function writeGhLock(params) {
   await writeFileContent(path2, content);
 }
 function serializeGhLock(lock) {
-  return dump4(lock, { noRefs: true, lineWidth: -1, sortKeys: false });
+  return dump3(lock, { noRefs: true, lineWidth: -1, sortKeys: false });
 }
 function findGhLockInstallation(lock, params) {
   const target = params.source.toLowerCase();
@@ -3000,39 +2933,7 @@ async function installGh(params) {
   if (sources.length === 0) {
     return { sourcesProcessed: 0, installedSkillCount: 0, failedSourceCount: 0 };
   }
-  const resolvedSources = sources.map((entry) => {
-    const parsed = parseSource(entry.source);
-    if (parsed.provider !== "github") {
-      throw new Error(
-        `--mode gh only supports GitHub sources. "${entry.source}" resolves to provider "${parsed.provider}".`
-      );
-    }
-    if (entry.transport !== void 0 && entry.transport !== "github") {
-      throw new Error(
-        `--mode gh: field "transport" is not supported (got "${entry.transport}" for source "${entry.source}"). Drop the field or switch to --mode rulesync.`
-      );
-    }
-    if (entry.path !== void 0) {
-      throw new Error(
-        `--mode gh: field "path" is not supported for source "${entry.source}". The remote layout is fixed to "skills/<name>/SKILL.md".`
-      );
-    }
-    const agent = entry.agent ?? "github-copilot";
-    if (!GH_AGENTS.includes(agent)) {
-      throw new Error(
-        `--mode gh: unknown agent "${agent}" for source "${entry.source}". Valid agents: ${GH_AGENTS.join(", ")}.`
-      );
-    }
-    const scope = entry.scope ?? "project";
-    return {
-      entry,
-      owner: parsed.owner,
-      repo: parsed.repo,
-      ref: entry.ref ?? parsed.ref,
-      agent,
-      scope
-    };
-  });
+  const resolvedSources = sources.map(resolveGhSource);
   const existingLock = await readGhLock(projectRoot);
   const frozen = options.frozen ?? false;
   const update = options.update ?? false;
@@ -3042,38 +2943,7 @@ async function installGh(params) {
     );
   }
   if (frozen && existingLock) {
-    const uncovered = [];
-    for (const rs of resolvedSources) {
-      const hasAny = existingLock.installations.some(
-        (i) => i.source.toLowerCase() === rs.entry.source.toLowerCase() && i.agent === rs.agent && i.scope === rs.scope
-      );
-      if (!hasAny) {
-        uncovered.push(`${rs.entry.source} (agent=${rs.agent}, scope=${rs.scope})`);
-      }
-    }
-    if (uncovered.length > 0) {
-      throw new Error(
-        `Frozen install failed: rulesync-gh.lock.yaml is missing entries for: ${uncovered.join(", ")}. Run 'rulesync install --mode gh' to update the lockfile.`
-      );
-    }
-    const drifted = [];
-    for (const rs of resolvedSources) {
-      if (!rs.ref) continue;
-      const matches = existingLock.installations.filter(
-        (i) => i.source.toLowerCase() === rs.entry.source.toLowerCase()
-      );
-      for (const m of matches) {
-        if (m.requested_ref !== void 0 && m.requested_ref !== rs.ref) {
-          drifted.push(`${rs.entry.source} (manifest=${rs.ref}, lock=${m.requested_ref})`);
-          break;
-        }
-      }
-    }
-    if (drifted.length > 0) {
-      throw new Error(
-        `Frozen install failed: manifest ref does not match rulesync-gh.lock.yaml for: ${drifted.join(", ")}. Run 'rulesync install --mode gh' to update the lockfile.`
-      );
-    }
+    assertFrozenLockCoversSources({ existingLock, resolvedSources });
   }
   const token = GitHubClient.resolveToken(options.token);
   const client = new GitHubClient({ token });
@@ -3109,15 +2979,109 @@ async function installGh(params) {
     })
   );
   if (frozen) {
-    for (const result of results) {
-      if (result.status !== "ok") continue;
-      for (const inst of result.installations) {
-        for (const d of inst.deployed) {
-          await writeFileContent(d.absolutePath, d.content);
-        }
+    await writeDeferredFrozenFiles(results);
+  }
+  const { totalInstalled, failedCount } = aggregateSourceResults({ results, newLock });
+  if (existingLock) {
+    await removeStaleGhFiles({ existingLock, newLock, projectRoot, logger: logger5 });
+  }
+  if (!frozen) {
+    newLock.generated_at = (/* @__PURE__ */ new Date()).toISOString();
+    await writeGhLock({ projectRoot, lock: newLock });
+    if (failedCount === 0) {
+      logger5.debug("rulesync-gh.lock.yaml updated.");
+    } else {
+      logger5.warn(
+        `rulesync-gh.lock.yaml written with partially successful installs (${failedCount} source(s) failed).`
+      );
+    }
+  }
+  return {
+    sourcesProcessed: sources.length,
+    installedSkillCount: totalInstalled,
+    failedSourceCount: failedCount
+  };
+}
+function resolveGhSource(entry) {
+  const parsed = parseSource(entry.source);
+  if (parsed.provider !== "github") {
+    throw new Error(
+      `--mode gh only supports GitHub sources. "${entry.source}" resolves to provider "${parsed.provider}".`
+    );
+  }
+  if (entry.transport !== void 0 && entry.transport !== "github") {
+    throw new Error(
+      `--mode gh: field "transport" is not supported (got "${entry.transport}" for source "${entry.source}"). Drop the field or switch to --mode rulesync.`
+    );
+  }
+  if (entry.path !== void 0) {
+    throw new Error(
+      `--mode gh: field "path" is not supported for source "${entry.source}". The remote layout is fixed to "skills/<name>/SKILL.md".`
+    );
+  }
+  const agent = entry.agent ?? "github-copilot";
+  if (!GH_AGENTS.includes(agent)) {
+    throw new Error(
+      `--mode gh: unknown agent "${agent}" for source "${entry.source}". Valid agents: ${GH_AGENTS.join(", ")}.`
+    );
+  }
+  const scope = entry.scope ?? "project";
+  return {
+    entry,
+    owner: parsed.owner,
+    repo: parsed.repo,
+    ref: entry.ref ?? parsed.ref,
+    agent,
+    scope
+  };
+}
+function assertFrozenLockCoversSources(params) {
+  const { existingLock, resolvedSources } = params;
+  const uncovered = [];
+  for (const rs of resolvedSources) {
+    const hasAny = existingLock.installations.some(
+      (i) => i.source.toLowerCase() === rs.entry.source.toLowerCase() && i.agent === rs.agent && i.scope === rs.scope
+    );
+    if (!hasAny) {
+      uncovered.push(`${rs.entry.source} (agent=${rs.agent}, scope=${rs.scope})`);
+    }
+  }
+  if (uncovered.length > 0) {
+    throw new Error(
+      `Frozen install failed: rulesync-gh.lock.yaml is missing entries for: ${uncovered.join(", ")}. Run 'rulesync install --mode gh' to update the lockfile.`
+    );
+  }
+  const drifted = [];
+  for (const rs of resolvedSources) {
+    if (!rs.ref) continue;
+    const matches = existingLock.installations.filter(
+      (i) => i.source.toLowerCase() === rs.entry.source.toLowerCase()
+    );
+    for (const m of matches) {
+      if (m.requested_ref !== void 0 && m.requested_ref !== rs.ref) {
+        drifted.push(`${rs.entry.source} (manifest=${rs.ref}, lock=${m.requested_ref})`);
+        break;
+      }
+    }
+  }
+  if (drifted.length > 0) {
+    throw new Error(
+      `Frozen install failed: manifest ref does not match rulesync-gh.lock.yaml for: ${drifted.join(", ")}. Run 'rulesync install --mode gh' to update the lockfile.`
+    );
+  }
+}
+async function writeDeferredFrozenFiles(results) {
+  for (const result of results) {
+    if (result.status !== "ok") continue;
+    for (const inst of result.installations) {
+      for (const d of inst.deployed) {
+        await writeFileContent(d.absolutePath, d.content);
       }
     }
   }
+}
+function aggregateSourceResults(params) {
+  const { results, newLock } = params;
   let totalInstalled = 0;
   let failedCount = 0;
   for (const result of results) {
@@ -3133,47 +3097,135 @@ async function installGh(params) {
       }
     }
   }
-  if (existingLock) {
-    const newDeployed = /* @__PURE__ */ new Set();
-    for (const inst of newLock.installations) {
-      for (const file of inst.deployed_files) {
-        newDeployed.add(`${inst.scope}::${file}`);
-      }
-    }
-    for (const prev of existingLock.installations) {
-      for (const deployed of prev.deployed_files) {
-        const key = `${prev.scope}::${deployed}`;
-        if (newDeployed.has(key)) continue;
-        await removeStaleFile({
-          relativePath: deployed,
-          scope: prev.scope === "user" ? "user" : "project",
-          projectRoot,
-          logger: logger5
-        });
-      }
+  return { totalInstalled, failedCount };
+}
+async function removeStaleGhFiles(params) {
+  const { existingLock, newLock, projectRoot, logger: logger5 } = params;
+  const newDeployed = /* @__PURE__ */ new Set();
+  for (const inst of newLock.installations) {
+    for (const file of inst.deployed_files) {
+      newDeployed.add(`${inst.scope}::${file}`);
     }
   }
-  if (!frozen) {
-    newLock.generated_at = (/* @__PURE__ */ new Date()).toISOString();
-    await writeGhLock({ projectRoot, lock: newLock });
-    if (failedCount === 0) {
-      logger5.debug("rulesync-gh.lock.yaml updated.");
-    } else {
-      logger5.warn(
-        `rulesync-gh.lock.yaml written with partially successful installs (${failedCount} source(s) failed).`
-      );
+  for (const prev of existingLock.installations) {
+    for (const deployed of prev.deployed_files) {
+      const key = `${prev.scope}::${deployed}`;
+      if (newDeployed.has(key)) continue;
+      await removeStaleFile({
+        relativePath: deployed,
+        scope: prev.scope === "user" ? "user" : "project",
+        projectRoot,
+        logger: logger5
+      });
     }
   }
-  return {
-    sourcesProcessed: sources.length,
-    installedSkillCount: totalInstalled,
-    failedSourceCount: failedCount
-  };
 }
 async function installSource(params) {
   const { rs, client, semaphore, projectRoot, existingLock, frozen, update, logger: logger5 } = params;
   const { entry, owner, repo, agent, scope } = rs;
   const sourceKey = entry.source;
+  const { resolvedRef, resolvedSha, usedTag } = await resolveGhRef({
+    rs,
+    client,
+    owner,
+    repo,
+    sourceKey,
+    logger: logger5
+  });
+  const validatedSkills = await discoverValidatedSkills({
+    client,
+    semaphore,
+    owner,
+    repo,
+    resolvedSha,
+    sourceKey,
+    logger: logger5
+  });
+  if (validatedSkills === null) {
+    return [];
+  }
+  const selected = selectSkills({ validatedSkills, entry, sourceKey, logger: logger5 });
+  if (frozen && existingLock) {
+    assertFrozenSkillCoverage({ selected, existingLock, sourceKey, agent, scope });
+  }
+  const results = [];
+  const installRelDir = relativeInstallDirFor({ agent, scope });
+  const scopeRoot = scope === "user" ? getHomeDirectory() : projectRoot;
+  const sourceUrl = `https://github.com/${owner}/${repo}`;
+  const repository = `${owner}/${repo}`;
+  const provenanceRef = usedTag ? resolvedRef : resolvedSha;
+  for (const sk of selected) {
+    const locked = existingLock && !update ? findGhLockInstallation(existingLock, {
+      source: sourceKey,
+      agent,
+      scope,
+      skill: sk.name
+    }) : void 0;
+    const allFiles = await listDirectoryRecursive({
+      client,
+      owner,
+      repo,
+      path: sk.path,
+      ref: resolvedSha,
+      semaphore
+    });
+    const deployed = await buildSkillDeployment({
+      sk,
+      allFiles,
+      client,
+      semaphore,
+      owner,
+      repo,
+      resolvedSha,
+      installRelDir,
+      scopeRoot,
+      sourceUrl,
+      repository,
+      provenanceRef,
+      sourceKey,
+      frozen,
+      logger: logger5
+    });
+    deployed.sort(
+      (a, b) => a.relativeToScopeRoot < b.relativeToScopeRoot ? -1 : a.relativeToScopeRoot > b.relativeToScopeRoot ? 1 : 0
+    );
+    const deployedFiles = deployed.map((d) => d.relativeToScopeRoot);
+    const contentHash = computeContentHash2(deployed);
+    assertFrozenSkillIntegrity({
+      frozen,
+      locked,
+      contentHash,
+      sourceKey,
+      skillName: sk.name,
+      agent,
+      scope,
+      logger: logger5
+    });
+    const installation = {
+      source: sourceKey,
+      owner,
+      repo,
+      agent,
+      scope,
+      skill: sk.name,
+      resolved_ref: resolvedRef,
+      resolved_commit: resolvedSha,
+      install_dir: toPosixPath(installRelDir),
+      deployed_files: deployedFiles,
+      content_hash: contentHash
+    };
+    if (rs.ref !== void 0) {
+      installation.requested_ref = rs.ref;
+    }
+    results.push({ installation, deployed });
+    logger5.info(
+      `Installed gh skill "${sk.name}" from ${sourceKey} (agent=${agent}, scope=${scope}, ref=${resolvedRef})`
+    );
+  }
+  return results;
+}
+async function resolveGhRef(params) {
+  const { rs, client, owner, repo, sourceKey, logger: logger5 } = params;
   let resolvedRef;
   let usedTag = false;
   if (rs.ref) {
@@ -3193,13 +3245,17 @@ async function installSource(params) {
   }
   const resolvedSha = await client.resolveRefToSha(owner, repo, resolvedRef);
   logger5.debug(`Resolved ${sourceKey} -> ref=${resolvedRef} sha=${resolvedSha}`);
+  return { resolvedRef, resolvedSha, usedTag };
+}
+async function discoverValidatedSkills(params) {
+  const { client, semaphore, owner, repo, resolvedSha, sourceKey, logger: logger5 } = params;
   let topLevel;
   try {
     topLevel = await client.listDirectory(owner, repo, SKILLS_REMOTE_DIR, resolvedSha);
   } catch (error) {
     if (is404(error)) {
       logger5.warn(`No skills/ directory found in ${sourceKey}. Skipping.`);
-      return [];
+      return null;
     }
     throw error;
   }
@@ -3214,152 +3270,133 @@ async function installSource(params) {
       validatedSkills.push(sk);
     }
   }
-  let selected = validatedSkills;
-  if (entry.skills && entry.skills.length > 0) {
-    const requested = new Set(entry.skills);
-    selected = validatedSkills.filter((s) => requested.has(s.name));
-    const presentNames = new Set(validatedSkills.map((s) => s.name));
-    for (const want of entry.skills) {
-      if (!presentNames.has(want)) {
-        logger5.warn(`Requested skill "${want}" not found in ${sourceKey} under skills/. Skipping.`);
-      }
-    }
+  return validatedSkills;
+}
+function selectSkills(params) {
+  const { validatedSkills, entry, sourceKey, logger: logger5 } = params;
+  if (!entry.skills || entry.skills.length === 0) {
+    return validatedSkills;
   }
-  if (frozen && existingLock) {
-    const missing = [];
-    for (const sk of selected) {
-      const locked = findGhLockInstallation(existingLock, {
-        source: sourceKey,
-        agent,
-        scope,
-        skill: sk.name
-      });
-      if (!locked) {
-        missing.push(sk.name);
-      }
-    }
-    if (missing.length > 0) {
-      throw new Error(
-        `Frozen install failed: rulesync-gh.lock.yaml is missing entries for ${sourceKey} (agent=${agent}, scope=${scope}) skills: ${missing.join(", ")}. Run 'rulesync install --mode gh' to update the lockfile.`
-      );
+  const requested = new Set(entry.skills);
+  const selected = validatedSkills.filter((s) => requested.has(s.name));
+  const presentNames = new Set(validatedSkills.map((s) => s.name));
+  for (const want of entry.skills) {
+    if (!presentNames.has(want)) {
+      logger5.warn(`Requested skill "${want}" not found in ${sourceKey} under skills/. Skipping.`);
     }
   }
-  const results = [];
-  const installRelDir = relativeInstallDirFor({ agent, scope });
-  const scopeRoot = scope === "user" ? getHomeDirectory() : projectRoot;
-  const sourceUrl = `https://github.com/${owner}/${repo}`;
-  const repository = `${owner}/${repo}`;
-  const provenanceRef = usedTag ? resolvedRef : resolvedSha;
+  return selected;
+}
+function assertFrozenSkillCoverage(params) {
+  const { selected, existingLock, sourceKey, agent, scope } = params;
+  const missing = [];
   for (const sk of selected) {
-    const locked = existingLock && !update ? findGhLockInstallation(existingLock, {
+    const locked = findGhLockInstallation(existingLock, {
       source: sourceKey,
       agent,
       scope,
       skill: sk.name
-    }) : void 0;
-    const allFiles = await listDirectoryRecursive({
-      client,
-      owner,
-      repo,
-      path: sk.path,
-      ref: resolvedSha,
-      semaphore
     });
-    const deployed = [];
-    for (const file of allFiles) {
-      if (file.size > MAX_FILE_SIZE) {
-        logger5.warn(
-          `Skipping "${file.path}" from ${sourceKey}: ${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
-        );
-        continue;
-      }
-      const relativeToSkill = posix3.relative(sk.path, toPosixPath(file.path));
-      if (!relativeToSkill || relativeToSkill.startsWith("..") || posix3.isAbsolute(relativeToSkill)) {
-        logger5.warn(`Skipping "${file.path}" from ${sourceKey}: resolved outside of "${sk.path}".`);
-        continue;
-      }
-      const deployRelative = toPosixPath(join9(installRelDir, sk.name, relativeToSkill));
-      checkPathTraversal({ relativePath: deployRelative, intendedRootDir: scopeRoot });
-      const installAbs = join9(scopeRoot, installRelDir);
-      const withinInstallDir = toPosixPath(join9(sk.name, relativeToSkill));
-      checkPathTraversal({ relativePath: withinInstallDir, intendedRootDir: installAbs });
-      let content = await withSemaphore(
-        semaphore,
-        () => client.getFileContent(owner, repo, file.path, resolvedSha)
+    if (!locked) {
+      missing.push(sk.name);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Frozen install failed: rulesync-gh.lock.yaml is missing entries for ${sourceKey} (agent=${agent}, scope=${scope}) skills: ${missing.join(", ")}. Run 'rulesync install --mode gh' to update the lockfile.`
+    );
+  }
+}
+async function buildSkillDeployment(params) {
+  const {
+    sk,
+    allFiles,
+    client,
+    semaphore,
+    owner,
+    repo,
+    resolvedSha,
+    installRelDir,
+    scopeRoot,
+    sourceUrl,
+    repository,
+    provenanceRef,
+    sourceKey,
+    frozen,
+    logger: logger5
+  } = params;
+  const deployed = [];
+  for (const file of allFiles) {
+    if (file.size > MAX_FILE_SIZE) {
+      logger5.warn(
+        `Skipping "${file.path}" from ${sourceKey}: ${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
+      );
+      continue;
+    }
+    const relativeToSkill = posix3.relative(sk.path, toPosixPath(file.path));
+    if (!relativeToSkill || relativeToSkill.startsWith("..") || posix3.isAbsolute(relativeToSkill)) {
+      logger5.warn(`Skipping "${file.path}" from ${sourceKey}: resolved outside of "${sk.path}".`);
+      continue;
+    }
+    const deployRelative = toPosixPath(join9(installRelDir, sk.name, relativeToSkill));
+    checkPathTraversal({ relativePath: deployRelative, intendedRootDir: scopeRoot });
+    const installAbs = join9(scopeRoot, installRelDir);
+    const withinInstallDir = toPosixPath(join9(sk.name, relativeToSkill));
+    checkPathTraversal({ relativePath: withinInstallDir, intendedRootDir: installAbs });
+    let content = await withSemaphore(
+      semaphore,
+      () => client.getFileContent(owner, repo, file.path, resolvedSha)
+    );
+    const byteLength = Buffer.byteLength(content, "utf8");
+    if (byteLength > MAX_FILE_SIZE) {
+      logger5.warn(
+        `Skipping "${file.path}" from ${sourceKey}: fetched ${(byteLength / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
       );
-      const byteLength = Buffer.byteLength(content, "utf8");
-      if (byteLength > MAX_FILE_SIZE) {
+      continue;
+    }
+    if (basename(file.path) === SKILL_FILE_NAME2) {
+      try {
+        content = injectSourceMetadata({
+          content,
+          source: sourceUrl,
+          repository,
+          ref: provenanceRef
+        });
+      } catch {
         logger5.warn(
-          `Skipping "${file.path}" from ${sourceKey}: fetched ${(byteLength / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit.`
+          `Frontmatter in ${file.path} (${sourceKey}) is invalid. Prepending a fresh provenance block.`
         );
-        continue;
-      }
-      if (basename(file.path) === SKILL_FILE_NAME2) {
-        try {
-          content = injectSourceMetadata({
-            content,
-            source: sourceUrl,
-            repository,
-            ref: provenanceRef
-          });
-        } catch {
-          logger5.warn(
-            `Frontmatter in ${file.path} (${sourceKey}) is invalid. Prepending a fresh provenance block.`
-          );
-          content = `---
+        content = `---
 source: ${sourceUrl}
 repository: ${repository}
 ref: ${provenanceRef}
 ---
 ${content}`;
-        }
-      }
-      const absolutePath = join9(scopeRoot, deployRelative);
-      deployed.push({ relativeToScopeRoot: deployRelative, absolutePath, content });
-      if (!frozen) {
-        await writeFileContent(absolutePath, content);
       }
     }
-    deployed.sort(
-      (a, b) => a.relativeToScopeRoot < b.relativeToScopeRoot ? -1 : a.relativeToScopeRoot > b.relativeToScopeRoot ? 1 : 0
-    );
-    const deployedFiles = deployed.map((d) => d.relativeToScopeRoot);
-    const contentHash = computeContentHash2(deployed);
-    if (frozen && locked?.content_hash) {
-      if (RULESYNC_CONTENT_HASH_REGEX2.test(locked.content_hash)) {
-        if (locked.content_hash !== contentHash) {
-          throw new Error(
-            `content_hash mismatch for ${sourceKey} skill "${sk.name}" (agent=${agent}, scope=${scope}): lock=${locked.content_hash} computed=${contentHash}. Refuse to trust the deployment under --frozen.`
-          );
-        }
-      } else {
-        logger5.debug(
-          `Skipping content_hash integrity check for ${sourceKey} skill "${sk.name}": recorded hash "${locked.content_hash}" was not written by rulesync.`
+    const absolutePath = join9(scopeRoot, deployRelative);
+    deployed.push({ relativeToScopeRoot: deployRelative, absolutePath, content });
+    if (!frozen) {
+      await writeFileContent(absolutePath, content);
+    }
+  }
+  return deployed;
+}
+function assertFrozenSkillIntegrity(params) {
+  const { frozen, locked, contentHash, sourceKey, skillName, agent, scope, logger: logger5 } = params;
+  if (frozen && locked?.content_hash) {
+    if (RULESYNC_CONTENT_HASH_REGEX2.test(locked.content_hash)) {
+      if (locked.content_hash !== contentHash) {
+        throw new Error(
+          `content_hash mismatch for ${sourceKey} skill "${skillName}" (agent=${agent}, scope=${scope}): lock=${locked.content_hash} computed=${contentHash}. Refuse to trust the deployment under --frozen.`
         );
       }
+    } else {
+      logger5.debug(
+        `Skipping content_hash integrity check for ${sourceKey} skill "${skillName}": recorded hash "${locked.content_hash}" was not written by rulesync.`
+      );
     }
-    const installation = {
-      source: sourceKey,
-      owner,
-      repo,
-      agent,
-      scope,
-      skill: sk.name,
-      resolved_ref: resolvedRef,
-      resolved_commit: resolvedSha,
-      install_dir: toPosixPath(installRelDir),
-      deployed_files: deployedFiles,
-      content_hash: contentHash
-    };
-    if (rs.ref !== void 0) {
-      installation.requested_ref = rs.ref;
-    }
-    results.push({ installation, deployed });
-    logger5.info(
-      `Installed gh skill "${sk.name}" from ${sourceKey} (agent=${agent}, scope=${scope}, ref=${resolvedRef})`
-    );
   }
-  return results;
 }
 async function removeStaleFile(params) {
   const { relativePath, scope, projectRoot, logger: logger5 } = params;
@@ -3752,18 +3789,7 @@ async function resolveAndFetchSources(params) {
   }
   let lock = options.updateSources ? createEmptyLock() : await readLockFile({ projectRoot, logger: logger5 });
   if (options.frozen) {
-    const missingKeys = [];
-    for (const source of sources) {
-      const locked = getLockedSource(lock, source.source);
-      if (!locked) {
-        missingKeys.push(source.source);
-      }
-    }
-    if (missingKeys.length > 0) {
-      throw new Error(
-        `Frozen install failed: lockfile is missing entries for: ${missingKeys.join(", ")}. Run 'rulesync install' to update the lockfile.`
-      );
-    }
+    assertFrozenLockCoversSources2({ lock, sources });
   }
   const originalLockJson = JSON.stringify(lock);
   const token = GitHubClient.resolveToken(options.token);
@@ -3773,31 +3799,17 @@ async function resolveAndFetchSources(params) {
   const allFetchedSkillNames = /* @__PURE__ */ new Set();
   for (const sourceEntry of sources) {
     try {
-      const transport = sourceEntry.transport ?? "github";
-      let result;
-      if (transport === "git") {
-        result = await fetchSourceViaGit({
-          sourceEntry,
-          projectRoot,
-          lock,
-          localSkillNames,
-          alreadyFetchedSkillNames: allFetchedSkillNames,
-          updateSources: options.updateSources ?? false,
-          frozen: options.frozen ?? false,
-          logger: logger5
-        });
-      } else {
-        result = await fetchSource({
-          sourceEntry,
-          client,
-          projectRoot,
-          lock,
-          localSkillNames,
-          alreadyFetchedSkillNames: allFetchedSkillNames,
-          updateSources: options.updateSources ?? false,
-          logger: logger5
-        });
-      }
+      const result = await fetchSourceByTransport({
+        sourceEntry,
+        client,
+        projectRoot,
+        lock,
+        localSkillNames,
+        alreadyFetchedSkillNames: allFetchedSkillNames,
+        updateSources: options.updateSources ?? false,
+        frozen: options.frozen ?? false,
+        logger: logger5
+      });
       const { skillCount, fetchedSkillNames, updatedLock } = result;
       lock = updatedLock;
       totalSkillCount += skillCount;
@@ -3813,16 +3825,7 @@ async function resolveAndFetchSources(params) {
       }
     }
   }
-  const sourceKeys = new Set(sources.map((s) => normalizeSourceKey(s.source)));
-  const prunedSources = {};
-  for (const [key, value] of Object.entries(lock.sources)) {
-    if (sourceKeys.has(normalizeSourceKey(key))) {
-      prunedSources[key] = value;
-    } else {
-      logger5.debug(`Pruned stale lockfile entry: ${key}`);
-    }
-  }
-  lock = { lockfileVersion: lock.lockfileVersion, sources: prunedSources };
+  lock = pruneStaleLockEntries({ lock, sources, logger: logger5 });
   if (!options.frozen && JSON.stringify(lock) !== originalLockJson) {
     await writeLockFile({ projectRoot, lock, logger: logger5 });
   } else {
@@ -3838,6 +3841,70 @@ function logGitClientHints(params) {
     logger5.info("Hint: Check your git credentials (SSH keys, credential helper, or access token).");
   }
 }
+function assertFrozenLockCoversSources2(params) {
+  const { lock, sources } = params;
+  const missingKeys = [];
+  for (const source of sources) {
+    const locked = getLockedSource(lock, source.source);
+    if (!locked) {
+      missingKeys.push(source.source);
+    }
+  }
+  if (missingKeys.length > 0) {
+    throw new Error(
+      `Frozen install failed: lockfile is missing entries for: ${missingKeys.join(", ")}. Run 'rulesync install' to update the lockfile.`
+    );
+  }
+}
+async function fetchSourceByTransport(params) {
+  const {
+    sourceEntry,
+    client,
+    projectRoot,
+    lock,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    updateSources,
+    frozen,
+    logger: logger5
+  } = params;
+  const transport = sourceEntry.transport ?? "github";
+  if (transport === "git") {
+    return fetchSourceViaGit({
+      sourceEntry,
+      projectRoot,
+      lock,
+      localSkillNames,
+      alreadyFetchedSkillNames,
+      updateSources,
+      frozen,
+      logger: logger5
+    });
+  }
+  return fetchSource({
+    sourceEntry,
+    client,
+    projectRoot,
+    lock,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    updateSources,
+    logger: logger5
+  });
+}
+function pruneStaleLockEntries(params) {
+  const { lock, sources, logger: logger5 } = params;
+  const sourceKeys = new Set(sources.map((s) => normalizeSourceKey(s.source)));
+  const prunedSources = {};
+  for (const [key, value] of Object.entries(lock.sources)) {
+    if (sourceKeys.has(normalizeSourceKey(key))) {
+      prunedSources[key] = value;
+    } else {
+      logger5.debug(`Pruned stale lockfile entry: ${key}`);
+    }
+  }
+  return { lockfileVersion: lock.lockfileVersion, sources: prunedSources };
+}
 async function checkLockedSkillsExist(curatedDir, skillNames) {
   if (skillNames.length === 0) return true;
   for (const name of skillNames) {
@@ -3969,7 +4036,189 @@ function groupRemoteFilesBySkillRoot(params) {
       grouped.set(singleSkillName, rootLevelFiles);
     }
   }
-  return grouped;
+  return grouped;
+}
+async function resolveGithubFetchRef(params) {
+  const { parsed, locked, updateSources, sourceKey, client, logger: logger5 } = params;
+  if (locked && !updateSources) {
+    logger5.debug(`Using locked ref for ${sourceKey}: ${locked.resolvedRef}`);
+    return {
+      ref: locked.resolvedRef,
+      resolvedSha: locked.resolvedRef,
+      requestedRef: locked.requestedRef
+    };
+  }
+  const requestedRef = parsed.ref ?? await client.getDefaultBranch(parsed.owner, parsed.repo);
+  const resolvedSha = await client.resolveRefToSha(parsed.owner, parsed.repo, requestedRef);
+  logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
+  return { ref: resolvedSha, resolvedSha, requestedRef };
+}
+async function fetchRootLevelFallbackSkill(params) {
+  const {
+    entries,
+    parsed,
+    ref,
+    resolvedSha,
+    skillFilter,
+    isWildcard,
+    curatedDir,
+    locked,
+    sourceKey,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    client,
+    semaphore,
+    fetchedSkills,
+    logger: logger5
+  } = params;
+  const rootFiles = entries.filter((entry) => entry.type === "file");
+  const rootSkillFiles = [];
+  for (const file of rootFiles) {
+    if (file.size > MAX_FILE_SIZE) {
+      logger5.warn(
+        `Skipping file "${file.path}" (${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit).`
+      );
+      continue;
+    }
+    const content = await withSemaphore(
+      semaphore,
+      () => client.getFileContent(parsed.owner, parsed.repo, file.path, ref)
+    );
+    rootSkillFiles.push({ relativePath: file.name, content });
+  }
+  const groupedRootFiles = groupRemoteFilesBySkillRoot({
+    remoteFiles: rootSkillFiles,
+    skillFilter,
+    isWildcard
+  });
+  const [fallbackSkillName] = groupedRootFiles.keys();
+  if (fallbackSkillName === void 0) {
+    return { handled: false, remoteSkillNames: [] };
+  }
+  if (!shouldSkipSkill({
+    skillName: fallbackSkillName,
+    sourceKey,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    logger: logger5
+  })) {
+    fetchedSkills[fallbackSkillName] = await writeSkillAndComputeIntegrity({
+      skillName: fallbackSkillName,
+      files: groupedRootFiles.get(fallbackSkillName) ?? [],
+      curatedDir,
+      locked,
+      resolvedSha,
+      sourceKey,
+      logger: logger5
+    });
+    logger5.debug(`Fetched skill "${fallbackSkillName}" from ${sourceKey}`);
+  }
+  return { handled: true, remoteSkillNames: [fallbackSkillName] };
+}
+async function fetchGithubSkillDir(params) {
+  const {
+    skillDir,
+    parsed,
+    ref,
+    resolvedSha,
+    curatedDir,
+    locked,
+    sourceKey,
+    client,
+    semaphore,
+    logger: logger5
+  } = params;
+  const allFiles = await listDirectoryRecursive({
+    client,
+    owner: parsed.owner,
+    repo: parsed.repo,
+    path: skillDir.path,
+    ref,
+    semaphore
+  });
+  const files = allFiles.filter((file) => {
+    if (file.size > MAX_FILE_SIZE) {
+      logger5.warn(
+        `Skipping file "${file.path}" (${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit).`
+      );
+      return false;
+    }
+    return true;
+  });
+  const skillFiles = [];
+  for (const file of files) {
+    const relativeToSkill = file.path.substring(skillDir.path.length + 1);
+    const content = await withSemaphore(
+      semaphore,
+      () => client.getFileContent(parsed.owner, parsed.repo, file.path, ref)
+    );
+    skillFiles.push({ relativePath: relativeToSkill, content });
+  }
+  return writeSkillAndComputeIntegrity({
+    skillName: skillDir.name,
+    files: skillFiles,
+    curatedDir,
+    locked,
+    resolvedSha,
+    sourceKey,
+    logger: logger5
+  });
+}
+async function discoverGithubSkillDirs(params) {
+  const {
+    parsed,
+    ref,
+    resolvedSha,
+    skillFilter,
+    isWildcard,
+    curatedDir,
+    locked,
+    sourceKey,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    client,
+    semaphore,
+    fetchedSkills,
+    logger: logger5
+  } = params;
+  const skillsBasePath = parsed.path ?? "skills";
+  try {
+    const entries = await client.listDirectory(parsed.owner, parsed.repo, skillsBasePath, ref);
+    const remoteSkillDirs = entries.filter((e) => e.type === "dir").map((e) => ({ name: e.name, path: e.path }));
+    if (remoteSkillDirs.length === 0 && !isWildcard && skillFilter.length === 1) {
+      const fallback = await fetchRootLevelFallbackSkill({
+        entries,
+        parsed,
+        ref,
+        resolvedSha,
+        skillFilter,
+        isWildcard,
+        curatedDir,
+        locked,
+        sourceKey,
+        localSkillNames,
+        alreadyFetchedSkillNames,
+        client,
+        semaphore,
+        fetchedSkills,
+        logger: logger5
+      });
+      if (fallback.handled) {
+        return {
+          status: "ok",
+          remoteSkillDirs,
+          fallbackHandled: true,
+          remoteSkillNames: fallback.remoteSkillNames
+        };
+      }
+    }
+    return { status: "ok", remoteSkillDirs, fallbackHandled: false, remoteSkillNames: [] };
+  } catch (error) {
+    if (error instanceof GitHubClientError && error.statusCode === 404) {
+      return { status: "notFound" };
+    }
+    throw error;
+  }
 }
 async function fetchSource(params) {
   const {
@@ -3990,20 +4239,14 @@ async function fetchSource(params) {
   const sourceKey = sourceEntry.source;
   const locked = getLockedSource(lock, sourceKey);
   const lockedSkillNames = locked ? getLockedSkillNames(locked) : [];
-  let ref;
-  let resolvedSha;
-  let requestedRef;
-  if (locked && !updateSources) {
-    ref = locked.resolvedRef;
-    resolvedSha = locked.resolvedRef;
-    requestedRef = locked.requestedRef;
-    logger5.debug(`Using locked ref for ${sourceKey}: ${resolvedSha}`);
-  } else {
-    requestedRef = parsed.ref ?? await client.getDefaultBranch(parsed.owner, parsed.repo);
-    resolvedSha = await client.resolveRefToSha(parsed.owner, parsed.repo, requestedRef);
-    ref = resolvedSha;
-    logger5.debug(`Resolved ${sourceKey} ref "${requestedRef}" to SHA: ${resolvedSha}`);
-  }
+  const { ref, resolvedSha, requestedRef } = await resolveGithubFetchRef({
+    parsed,
+    locked,
+    updateSources,
+    sourceKey,
+    client,
+    logger: logger5
+  });
   const curatedDir = join12(projectRoot, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH);
   if (locked && resolvedSha === locked.resolvedRef && !updateSources) {
     const allExist = await checkLockedSkillsExist(curatedDir, lockedSkillNames);
@@ -4020,69 +4263,29 @@ async function fetchSource(params) {
   const isWildcard = skillFilter.length === 1 && skillFilter[0] === "*";
   const semaphore = new Semaphore4(FETCH_CONCURRENCY_LIMIT);
   const fetchedSkills = {};
-  const skillsBasePath = parsed.path ?? "skills";
-  let remoteSkillDirs;
-  let remoteSkillNames = [];
-  let fallbackHandled = false;
-  try {
-    const entries = await client.listDirectory(parsed.owner, parsed.repo, skillsBasePath, ref);
-    remoteSkillDirs = entries.filter((e) => e.type === "dir").map((e) => ({ name: e.name, path: e.path }));
-    if (remoteSkillDirs.length === 0 && !isWildcard && skillFilter.length === 1) {
-      const rootFiles = entries.filter((entry) => entry.type === "file");
-      const rootSkillFiles = [];
-      for (const file of rootFiles) {
-        if (file.size > MAX_FILE_SIZE) {
-          logger5.warn(
-            `Skipping file "${file.path}" (${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit).`
-          );
-          continue;
-        }
-        const content = await withSemaphore(
-          semaphore,
-          () => client.getFileContent(parsed.owner, parsed.repo, file.path, ref)
-        );
-        rootSkillFiles.push({ relativePath: file.name, content });
-      }
-      const groupedRootFiles = groupRemoteFilesBySkillRoot({
-        remoteFiles: rootSkillFiles,
-        skillFilter,
-        isWildcard
-      });
-      const [fallbackSkillName] = groupedRootFiles.keys();
-      if (fallbackSkillName !== void 0) {
-        fallbackHandled = true;
-        remoteSkillNames = [fallbackSkillName];
-        if (!shouldSkipSkill({
-          skillName: fallbackSkillName,
-          sourceKey,
-          localSkillNames,
-          alreadyFetchedSkillNames,
-          logger: logger5
-        })) {
-          fetchedSkills[fallbackSkillName] = await writeSkillAndComputeIntegrity({
-            skillName: fallbackSkillName,
-            files: groupedRootFiles.get(fallbackSkillName) ?? [],
-            curatedDir,
-            locked,
-            resolvedSha,
-            sourceKey,
-            logger: logger5
-          });
-          logger5.debug(`Fetched skill "${fallbackSkillName}" from ${sourceKey}`);
-        }
-      }
-    }
-  } catch (error) {
-    if (error instanceof GitHubClientError && error.statusCode === 404) {
-      logger5.warn(`No skills/ directory found in ${sourceKey}. Skipping.`);
-      return { skillCount: 0, fetchedSkillNames: [], updatedLock: lock };
-    }
-    throw error;
+  const discovery = await discoverGithubSkillDirs({
+    parsed,
+    ref,
+    resolvedSha,
+    skillFilter,
+    isWildcard,
+    curatedDir,
+    locked,
+    sourceKey,
+    localSkillNames,
+    alreadyFetchedSkillNames,
+    client,
+    semaphore,
+    fetchedSkills,
+    logger: logger5
+  });
+  if (discovery.status === "notFound") {
+    logger5.warn(`No skills/ directory found in ${sourceKey}. Skipping.`);
+    return { skillCount: 0, fetchedSkillNames: [], updatedLock: lock };
   }
+  const { remoteSkillDirs, fallbackHandled, remoteSkillNames: fallbackSkillNames } = discovery;
   const filteredDirs = isWildcard ? remoteSkillDirs : remoteSkillDirs.filter((d) => skillFilter.includes(d.name));
-  if (!fallbackHandled) {
-    remoteSkillNames = filteredDirs.map((d) => d.name);
-  }
+  const remoteSkillNames = fallbackHandled ? fallbackSkillNames : filteredDirs.map((d) => d.name);
   if (locked) {
     await cleanPreviousCuratedSkills({ curatedDir, lockedSkillNames, logger: logger5 });
   }
@@ -4096,39 +4299,16 @@ async function fetchSource(params) {
     })) {
       continue;
     }
-    const allFiles = await listDirectoryRecursive({
-      client,
-      owner: parsed.owner,
-      repo: parsed.repo,
-      path: skillDir.path,
+    fetchedSkills[skillDir.name] = await fetchGithubSkillDir({
+      skillDir,
+      parsed,
       ref,
-      semaphore
-    });
-    const files = allFiles.filter((file) => {
-      if (file.size > MAX_FILE_SIZE) {
-        logger5.warn(
-          `Skipping file "${file.path}" (${(file.size / 1024 / 1024).toFixed(2)}MB exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit).`
-        );
-        return false;
-      }
-      return true;
-    });
-    const skillFiles = [];
-    for (const file of files) {
-      const relativeToSkill = file.path.substring(skillDir.path.length + 1);
-      const content = await withSemaphore(
-        semaphore,
-        () => client.getFileContent(parsed.owner, parsed.repo, file.path, ref)
-      );
-      skillFiles.push({ relativePath: relativeToSkill, content });
-    }
-    fetchedSkills[skillDir.name] = await writeSkillAndComputeIntegrity({
-      skillName: skillDir.name,
-      files: skillFiles,
+      resolvedSha,
       curatedDir,
       locked,
-      resolvedSha,
       sourceKey,
+      client,
+      semaphore,
       logger: logger5
     });
     logger5.debug(`Fetched skill "${skillDir.name}" from ${sourceKey}`);
@@ -6037,6 +6217,174 @@ function ensureBody({ body, feature, operation }) {
   }
   return body;
 }
+function requireContent({
+  content,
+  feature
+}) {
+  if (!content) {
+    throw new Error(`content is required for ${feature} put operation`);
+  }
+  return content;
+}
+function executeRule(parsed) {
+  if (parsed.operation === "list") {
+    return ruleTools.listRules.execute();
+  }
+  if (parsed.operation === "get") {
+    return ruleTools.getRule.execute({ relativePathFromCwd: requireTargetPath(parsed) });
+  }
+  if (parsed.operation === "put") {
+    return ruleTools.putRule.execute({
+      relativePathFromCwd: requireTargetPath(parsed),
+      frontmatter: parseFrontmatter({
+        feature: "rule",
+        frontmatter: parsed.frontmatter ?? {}
+      }),
+      body: ensureBody(parsed)
+    });
+  }
+  return ruleTools.deleteRule.execute({ relativePathFromCwd: requireTargetPath(parsed) });
+}
+function executeCommand(parsed) {
+  if (parsed.operation === "list") {
+    return commandTools.listCommands.execute();
+  }
+  if (parsed.operation === "get") {
+    return commandTools.getCommand.execute({
+      relativePathFromCwd: requireTargetPath(parsed)
+    });
+  }
+  if (parsed.operation === "put") {
+    return commandTools.putCommand.execute({
+      relativePathFromCwd: requireTargetPath(parsed),
+      frontmatter: parseFrontmatter({
+        feature: "command",
+        frontmatter: parsed.frontmatter ?? {}
+      }),
+      body: ensureBody(parsed)
+    });
+  }
+  return commandTools.deleteCommand.execute({
+    relativePathFromCwd: requireTargetPath(parsed)
+  });
+}
+function executeSubagent(parsed) {
+  if (parsed.operation === "list") {
+    return subagentTools.listSubagents.execute();
+  }
+  if (parsed.operation === "get") {
+    return subagentTools.getSubagent.execute({
+      relativePathFromCwd: requireTargetPath(parsed)
+    });
+  }
+  if (parsed.operation === "put") {
+    return subagentTools.putSubagent.execute({
+      relativePathFromCwd: requireTargetPath(parsed),
+      frontmatter: parseFrontmatter({
+        feature: "subagent",
+        frontmatter: parsed.frontmatter ?? {}
+      }),
+      body: ensureBody(parsed)
+    });
+  }
+  return subagentTools.deleteSubagent.execute({
+    relativePathFromCwd: requireTargetPath(parsed)
+  });
+}
+function executeSkill(parsed) {
+  if (parsed.operation === "list") {
+    return skillTools.listSkills.execute();
+  }
+  if (parsed.operation === "get") {
+    return skillTools.getSkill.execute({ relativeDirPathFromCwd: requireTargetPath(parsed) });
+  }
+  if (parsed.operation === "put") {
+    return skillTools.putSkill.execute({
+      relativeDirPathFromCwd: requireTargetPath(parsed),
+      frontmatter: parseFrontmatter({
+        feature: "skill",
+        frontmatter: parsed.frontmatter ?? {}
+      }),
+      body: ensureBody(parsed),
+      otherFiles: parsed.otherFiles ?? []
+    });
+  }
+  return skillTools.deleteSkill.execute({
+    relativeDirPathFromCwd: requireTargetPath(parsed)
+  });
+}
+function executeIgnore(parsed) {
+  if (parsed.operation === "get") {
+    return ignoreTools.getIgnoreFile.execute();
+  }
+  if (parsed.operation === "put") {
+    return ignoreTools.putIgnoreFile.execute({
+      content: requireContent({ content: parsed.content, feature: "ignore" })
+    });
+  }
+  return ignoreTools.deleteIgnoreFile.execute();
+}
+function executeMcp(parsed) {
+  if (parsed.operation === "get") {
+    return mcpTools.getMcpFile.execute();
+  }
+  if (parsed.operation === "put") {
+    return mcpTools.putMcpFile.execute({
+      content: requireContent({ content: parsed.content, feature: "mcp" })
+    });
+  }
+  return mcpTools.deleteMcpFile.execute();
+}
+function executePermissions(parsed) {
+  if (parsed.operation === "get") {
+    return permissionsTools.getPermissionsFile.execute();
+  }
+  if (parsed.operation === "put") {
+    return permissionsTools.putPermissionsFile.execute({
+      content: requireContent({ content: parsed.content, feature: "permissions" })
+    });
+  }
+  return permissionsTools.deletePermissionsFile.execute();
+}
+function executeHooks(parsed) {
+  if (parsed.operation === "get") {
+    return hooksTools.getHooksFile.execute();
+  }
+  if (parsed.operation === "put") {
+    return hooksTools.putHooksFile.execute({
+      content: requireContent({ content: parsed.content, feature: "hooks" })
+    });
+  }
+  return hooksTools.deleteHooksFile.execute();
+}
+function executeGenerate2(parsed) {
+  return generateTools.executeGenerate.execute(parsed.generateOptions ?? {});
+}
+function executeImport2(parsed) {
+  if (!parsed.importOptions) {
+    throw new Error("importOptions is required for import feature");
+  }
+  return importTools.executeImport.execute(parsed.importOptions);
+}
+function executeConvert2(parsed) {
+  if (!parsed.convertOptions) {
+    throw new Error("convertOptions is required for convert feature");
+  }
+  return convertTools.executeConvert.execute(parsed.convertOptions);
+}
+var featureExecutors = {
+  rule: executeRule,
+  command: executeCommand,
+  subagent: executeSubagent,
+  skill: executeSkill,
+  ignore: executeIgnore,
+  mcp: executeMcp,
+  permissions: executePermissions,
+  hooks: executeHooks,
+  generate: executeGenerate2,
+  import: executeImport2,
+  convert: executeConvert2
+};
 var rulesyncTool = {
   name: "rulesyncTool",
   description: "Manage Rulesync files through a single MCP tool. Features: rule/command/subagent/skill support list/get/put/delete; ignore/mcp/permissions/hooks support get/put/delete only; generate supports run only; import supports run only; convert supports run only. Parameters: list requires no targetPathFromCwd (lists all items); get/delete require targetPathFromCwd; put requires targetPathFromCwd, frontmatter, and body (or content for ignore/mcp/permissions/hooks); generate/run uses generateOptions to configure generation; import/run uses importOptions to configure import; convert/run uses convertOptions to configure conversion.",
@@ -6044,161 +6392,11 @@ var rulesyncTool = {
   execute: async (args) => {
     const parsed = rulesyncToolSchema.parse(args);
     assertSupported({ feature: parsed.feature, operation: parsed.operation });
-    switch (parsed.feature) {
-      case "rule": {
-        if (parsed.operation === "list") {
-          return ruleTools.listRules.execute();
-        }
-        if (parsed.operation === "get") {
-          return ruleTools.getRule.execute({ relativePathFromCwd: requireTargetPath(parsed) });
-        }
-        if (parsed.operation === "put") {
-          return ruleTools.putRule.execute({
-            relativePathFromCwd: requireTargetPath(parsed),
-            frontmatter: parseFrontmatter({
-              feature: "rule",
-              frontmatter: parsed.frontmatter ?? {}
-            }),
-            body: ensureBody(parsed)
-          });
-        }
-        return ruleTools.deleteRule.execute({ relativePathFromCwd: requireTargetPath(parsed) });
-      }
-      case "command": {
-        if (parsed.operation === "list") {
-          return commandTools.listCommands.execute();
-        }
-        if (parsed.operation === "get") {
-          return commandTools.getCommand.execute({
-            relativePathFromCwd: requireTargetPath(parsed)
-          });
-        }
-        if (parsed.operation === "put") {
-          return commandTools.putCommand.execute({
-            relativePathFromCwd: requireTargetPath(parsed),
-            frontmatter: parseFrontmatter({
-              feature: "command",
-              frontmatter: parsed.frontmatter ?? {}
-            }),
-            body: ensureBody(parsed)
-          });
-        }
-        return commandTools.deleteCommand.execute({
-          relativePathFromCwd: requireTargetPath(parsed)
-        });
-      }
-      case "subagent": {
-        if (parsed.operation === "list") {
-          return subagentTools.listSubagents.execute();
-        }
-        if (parsed.operation === "get") {
-          return subagentTools.getSubagent.execute({
-            relativePathFromCwd: requireTargetPath(parsed)
-          });
-        }
-        if (parsed.operation === "put") {
-          return subagentTools.putSubagent.execute({
-            relativePathFromCwd: requireTargetPath(parsed),
-            frontmatter: parseFrontmatter({
-              feature: "subagent",
-              frontmatter: parsed.frontmatter ?? {}
-            }),
-            body: ensureBody(parsed)
-          });
-        }
-        return subagentTools.deleteSubagent.execute({
-          relativePathFromCwd: requireTargetPath(parsed)
-        });
-      }
-      case "skill": {
-        if (parsed.operation === "list") {
-          return skillTools.listSkills.execute();
-        }
-        if (parsed.operation === "get") {
-          return skillTools.getSkill.execute({ relativeDirPathFromCwd: requireTargetPath(parsed) });
-        }
-        if (parsed.operation === "put") {
-          return skillTools.putSkill.execute({
-            relativeDirPathFromCwd: requireTargetPath(parsed),
-            frontmatter: parseFrontmatter({
-              feature: "skill",
-              frontmatter: parsed.frontmatter ?? {}
-            }),
-            body: ensureBody(parsed),
-            otherFiles: parsed.otherFiles ?? []
-          });
-        }
-        return skillTools.deleteSkill.execute({
-          relativeDirPathFromCwd: requireTargetPath(parsed)
-        });
-      }
-      case "ignore": {
-        if (parsed.operation === "get") {
-          return ignoreTools.getIgnoreFile.execute();
-        }
-        if (parsed.operation === "put") {
-          if (!parsed.content) {
-            throw new Error("content is required for ignore put operation");
-          }
-          return ignoreTools.putIgnoreFile.execute({ content: parsed.content });
-        }
-        return ignoreTools.deleteIgnoreFile.execute();
-      }
-      case "mcp": {
-        if (parsed.operation === "get") {
-          return mcpTools.getMcpFile.execute();
-        }
-        if (parsed.operation === "put") {
-          if (!parsed.content) {
-            throw new Error("content is required for mcp put operation");
-          }
-          return mcpTools.putMcpFile.execute({ content: parsed.content });
-        }
-        return mcpTools.deleteMcpFile.execute();
-      }
-      case "permissions": {
-        if (parsed.operation === "get") {
-          return permissionsTools.getPermissionsFile.execute();
-        }
-        if (parsed.operation === "put") {
-          if (!parsed.content) {
-            throw new Error("content is required for permissions put operation");
-          }
-          return permissionsTools.putPermissionsFile.execute({ content: parsed.content });
-        }
-        return permissionsTools.deletePermissionsFile.execute();
-      }
-      case "hooks": {
-        if (parsed.operation === "get") {
-          return hooksTools.getHooksFile.execute();
-        }
-        if (parsed.operation === "put") {
-          if (!parsed.content) {
-            throw new Error("content is required for hooks put operation");
-          }
-          return hooksTools.putHooksFile.execute({ content: parsed.content });
-        }
-        return hooksTools.deleteHooksFile.execute();
-      }
-      case "generate": {
-        return generateTools.executeGenerate.execute(parsed.generateOptions ?? {});
-      }
-      case "import": {
-        if (!parsed.importOptions) {
-          throw new Error("importOptions is required for import feature");
-        }
-        return importTools.executeImport.execute(parsed.importOptions);
-      }
-      case "convert": {
-        if (!parsed.convertOptions) {
-          throw new Error("convertOptions is required for convert feature");
-        }
-        return convertTools.executeConvert.execute(parsed.convertOptions);
-      }
-      default: {
-        throw new Error(`Unknown feature: ${parsed.feature}`);
-      }
+    const executor = featureExecutors[parsed.feature];
+    if (!executor) {
+      throw new Error(`Unknown feature: ${parsed.feature}`);
     }
+    return executor(parsed);
   }
 };
 
@@ -6417,103 +6615,150 @@ function parseSha256Sums(content) {
   }
   return result;
 }
-async function performBinaryUpdate(currentVersion, options = {}) {
-  const { force = false, token } = options;
-  const updateCheck = await checkForUpdate(currentVersion, token);
-  if (!updateCheck.hasUpdate && !force) {
-    return `Already at the latest version (${currentVersion})`;
-  }
+function resolveUpdateAssets(release) {
   const assetName = getPlatformAssetName();
   if (!assetName) {
     throw new Error(
       `Unsupported platform: ${os.platform()} ${os.arch()}. Please download manually from ${RELEASES_URL}`
     );
   }
-  const binaryAsset = findAsset(updateCheck.release, assetName);
+  const binaryAsset = findAsset(release, assetName);
   if (!binaryAsset) {
     throw new Error(
       `Binary for ${assetName} not found in release. Please download manually from ${RELEASES_URL}`
     );
   }
-  const checksumAsset = findAsset(updateCheck.release, "SHA256SUMS");
+  const checksumAsset = findAsset(release, "SHA256SUMS");
   if (!checksumAsset) {
     throw new Error(
       `SHA256SUMS not found in release. Cannot verify download integrity. Please download manually from ${RELEASES_URL}`
     );
   }
-  const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rulesync-update-"));
-  let restoreFailed = false;
+  return { assetName, binaryAsset, checksumAsset };
+}
+async function downloadAndVerifyBinary(params) {
+  const { tempDir, assetName, binaryAsset, checksumAsset } = params;
+  const tempBinaryPath = path.join(tempDir, assetName);
+  await downloadFile(binaryAsset.browser_download_url, tempBinaryPath);
+  const checksumsPath = path.join(tempDir, "SHA256SUMS");
+  await downloadFile(checksumAsset.browser_download_url, checksumsPath);
+  const checksumsContent = await fs.promises.readFile(checksumsPath, "utf-8");
+  const checksums = parseSha256Sums(checksumsContent);
+  const expectedChecksum = checksums.get(assetName);
+  if (!expectedChecksum) {
+    throw new Error(
+      `Checksum entry for "${assetName}" not found in SHA256SUMS. Cannot verify download integrity.`
+    );
+  }
+  const actualChecksum = await calculateSha256(tempBinaryPath);
+  if (actualChecksum !== expectedChecksum) {
+    throw new Error(
+      `Checksum verification failed. Expected: ${expectedChecksum}, Got: ${actualChecksum}. The download may be corrupted.`
+    );
+  }
+  return tempBinaryPath;
+}
+async function replaceCurrentBinary(params) {
+  const { tempBinaryPath, currentExePath, currentDir } = params;
+  const tempInPlace = path.join(currentDir, `.rulesync-update-${crypto.randomUUID()}`);
   try {
+    await fs.promises.copyFile(tempBinaryPath, tempInPlace);
     if (os.platform() !== "win32") {
-      await fs.promises.chmod(tempDir, 448);
+      await fs.promises.chmod(tempInPlace, 493);
     }
-    const tempBinaryPath = path.join(tempDir, assetName);
-    await downloadFile(binaryAsset.browser_download_url, tempBinaryPath);
-    const checksumsPath = path.join(tempDir, "SHA256SUMS");
-    await downloadFile(checksumAsset.browser_download_url, checksumsPath);
-    const checksumsContent = await fs.promises.readFile(checksumsPath, "utf-8");
-    const checksums = parseSha256Sums(checksumsContent);
-    const expectedChecksum = checksums.get(assetName);
-    if (!expectedChecksum) {
-      throw new Error(
-        `Checksum entry for "${assetName}" not found in SHA256SUMS. Cannot verify download integrity.`
-      );
+    await fs.promises.rename(tempInPlace, currentExePath);
+  } catch {
+    try {
+      await fs.promises.unlink(tempInPlace);
+    } catch {
     }
-    const actualChecksum = await calculateSha256(tempBinaryPath);
-    if (actualChecksum !== expectedChecksum) {
-      throw new Error(
-        `Checksum verification failed. Expected: ${expectedChecksum}, Got: ${actualChecksum}. The download may be corrupted.`
-      );
+    await fs.promises.copyFile(tempBinaryPath, currentExePath);
+    if (os.platform() !== "win32") {
+      await fs.promises.chmod(currentExePath, 493);
     }
-    const currentExePath = await fs.promises.realpath(process.execPath);
-    const currentDir = path.dirname(currentExePath);
-    const backupPath = path.join(tempDir, "rulesync.backup");
-    try {
-      await fs.promises.copyFile(currentExePath, backupPath);
-    } catch (error) {
-      if (isPermissionError(error)) {
-        throw new UpdatePermissionError(
-          `Permission denied: Cannot read ${currentExePath}. Try running with sudo.`
-        );
-      }
-      throw error;
+  }
+}
+async function installVerifiedBinary(params) {
+  const { tempDir, tempBinaryPath, currentVersion, latestVersion } = params;
+  const currentExePath = await fs.promises.realpath(process.execPath);
+  const currentDir = path.dirname(currentExePath);
+  const backupPath = path.join(tempDir, "rulesync.backup");
+  try {
+    await fs.promises.copyFile(currentExePath, backupPath);
+  } catch (error) {
+    if (isPermissionError(error)) {
+      throw new UpdatePermissionError(
+        `Permission denied: Cannot read ${currentExePath}. Try running with sudo.`
+      );
     }
+    throw error;
+  }
+  try {
+    await replaceCurrentBinary({ tempBinaryPath, currentExePath, currentDir });
+    return {
+      message: `Successfully updated from ${currentVersion} to ${latestVersion}`,
+      restoreFailed: false
+    };
+  } catch (error) {
     try {
-      const tempInPlace = path.join(currentDir, `.rulesync-update-${crypto.randomUUID()}`);
-      try {
-        await fs.promises.copyFile(tempBinaryPath, tempInPlace);
-        if (os.platform() !== "win32") {
-          await fs.promises.chmod(tempInPlace, 493);
-        }
-        await fs.promises.rename(tempInPlace, currentExePath);
-      } catch {
-        try {
-          await fs.promises.unlink(tempInPlace);
-        } catch {
-        }
-        await fs.promises.copyFile(tempBinaryPath, currentExePath);
-        if (os.platform() !== "win32") {
-          await fs.promises.chmod(currentExePath, 493);
-        }
-      }
-      return `Successfully updated from ${currentVersion} to ${updateCheck.latestVersion}`;
-    } catch (error) {
-      try {
-        await fs.promises.copyFile(backupPath, currentExePath);
-      } catch {
-        restoreFailed = true;
-        throw new Error(
+      await fs.promises.copyFile(backupPath, currentExePath);
+    } catch {
+      throw new RestoreFailedError(
+        new Error(
           `Failed to replace binary and restore failed. Backup is preserved at: ${backupPath} (in ${tempDir}). Please manually copy it to ${currentExePath}. Original error: ${error instanceof Error ? error.message : String(error)}`,
           { cause: error }
-        );
-      }
-      if (isPermissionError(error)) {
-        throw new UpdatePermissionError(
-          `Permission denied: Cannot write to ${path.dirname(currentExePath)}. Try running with sudo.`
-        );
-      }
-      throw error;
+        )
+      );
+    }
+    if (isPermissionError(error)) {
+      throw new UpdatePermissionError(
+        `Permission denied: Cannot write to ${path.dirname(currentExePath)}. Try running with sudo.`
+      );
+    }
+    throw error;
+  }
+}
+var RestoreFailedError = class extends Error {
+  cause;
+  constructor(cause) {
+    super(cause.message);
+    this.name = "RestoreFailedError";
+    this.cause = cause;
+  }
+};
+async function performBinaryUpdate(currentVersion, options = {}) {
+  const { force = false, token } = options;
+  const updateCheck = await checkForUpdate(currentVersion, token);
+  if (!updateCheck.hasUpdate && !force) {
+    return `Already at the latest version (${currentVersion})`;
+  }
+  const { assetName, binaryAsset, checksumAsset } = resolveUpdateAssets(updateCheck.release);
+  const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rulesync-update-"));
+  let restoreFailed = false;
+  try {
+    if (os.platform() !== "win32") {
+      await fs.promises.chmod(tempDir, 448);
+    }
+    const tempBinaryPath = await downloadAndVerifyBinary({
+      tempDir,
+      assetName,
+      binaryAsset,
+      checksumAsset
+    });
+    const installed = await installVerifiedBinary({
+      tempDir,
+      tempBinaryPath,
+      currentVersion,
+      latestVersion: updateCheck.latestVersion
+    });
+    restoreFailed = installed.restoreFailed;
+    return installed.message;
+  } catch (error) {
+    if (error instanceof RestoreFailedError) {
+      restoreFailed = true;
+      throw error.cause;
     }
+    throw error;
   } finally {
     if (!restoreFailed) {
       try {
@@ -6644,7 +6889,7 @@ function wrapCommand({
 }
 
 // src/cli/index.ts
-var getVersion = () => "8.30.1";
+var getVersion = () => "8.32.0";
 function wrapCommand2(name, errorCode, handler) {
   return wrapCommand({ name, errorCode, handler, getVersion });
 }