@danieldeusing/seedr 0.1.97 → 0.1.99

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import {
+  AGENT_COMPATIBILITY,
   ALL_AGENTS,
+  ALL_TYPES,
   CODING_AGENTS,
   MAX_SLUG_LENGTH,
   SLUG_PATTERN,
@@ -11,8 +13,12 @@ import {
   brand,
   canonicalAgent,
   canonicalAgents,
+  claudeUserRoot,
+  codexUserRoot,
   confirm,
+  copilotUserRoot,
   copyDirectory,
+  deepMerge,
   ensureDir,
   error,
   exists,
@@ -33,15 +39,18 @@ import {
   intro,
   isInteractive,
   isLegacyAgent,
+  isTypeSupported,
   isValidSlug,
   listItems,
   mainFileName,
   moveDirectory,
+  openCodeUserConfigDir,
   outro,
   p,
   parseAgentsArgStrict,
   parseGitHubRepo,
   printLogo,
+  readJson,
   removePathEntry,
   resolveContained,
   restoreFile,
@@ -56,15 +65,16 @@ import {
   success,
   warn,
   writeFileAtomic,
+  writeJson,
   writeTextFile
-} from "./chunk-PEGEA2KN.js";
+} from "./chunk-3KPB5CCX.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
 
 // src/commands/add.ts
 import { Command } from "commander";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/handlers/registry.ts
 var handlers = /* @__PURE__ */ new Map();
@@ -104,15 +114,8 @@ function handleCommandError(error2) {
 // src/utils/validate-options.ts
 var SCOPES = ["project", "user", "local"];
 var METHODS = ["symlink", "copy"];
-var TYPES = [
-  "skill",
-  "hook",
-  "agent",
-  "plugin",
-  "command",
-  "settings",
-  "mcp"
-];
+var TYPES = ALL_TYPES;
+var TYPE_LIST = TYPES.join(", ");
 function validateScope(value) {
   if (value === void 0) return null;
   if (!SCOPES.includes(value)) {
@@ -144,7 +147,7 @@ function isTelemetryDisabled(env = process.env) {
   return env[TELEMETRY_OPT_OUT_VARIABLE] !== void 0;
 }
 function cliVersion() {
-  return true ? "0.1.97" : "dev";
+  return true ? "0.1.99" : "dev";
 }
 async function sendEvent(event) {
   try {
@@ -165,26 +168,12 @@ function trackInstalls(slug, type, results, scope) {
 }
 
 // src/config/compatibility.ts
-var AGENT_COMPATIBILITY = {
-  skill: ["claude", "copilot", "antigravity", "codex", "opencode"],
-  command: ["claude"],
-  agent: ["claude"],
-  hook: ["claude"],
-  plugin: ["claude"],
-  settings: ["claude"],
-  mcp: ["claude", "codex", "opencode"]
-};
-function isTypeSupported(type, agent) {
-  const canonical = canonicalAgent(agent);
-  return canonical !== null && AGENT_COMPATIBILITY[type].includes(canonical);
-}
 function filterCompatibleAgents(type, agents) {
   const compatible = AGENT_COMPATIBILITY[type];
   return canonicalAgents(agents).filter((a) => compatible.includes(a));
 }
 var MCP_UNSUPPORTED_REASONS = {
-  copilot: "GitHub Copilot's MCP configuration format could not be verified against primary documentation, so seedr does not write it",
-  antigravity: "Google Antigravity's MCP configuration format could not be verified against primary documentation, so seedr does not write it"
+  antigravity: "Google Antigravity's MCP file name is documented but its schema has never been observed \u2014 the file is empty on every machine checked \u2014 so seedr does not guess at it"
 };
 function describeIncompatibility(type, agent) {
   const canonical = canonicalAgent(agent);
@@ -201,11 +190,14 @@ import { lstat, readdir, unlink } from "fs/promises";
 import chalk2 from "chalk";
 import ora from "ora";
 var SLUG_LABEL = "agent slug";
+function subagentFileName(agent, slug) {
+  return (canonicalAgent(agent) ?? agent) === "copilot" ? `${slug}.agent.md` : `${slug}.md`;
+}
 async function resolveAgentFilePath(agent, slug, scope, cwd) {
   const destDir = getContentPath(agent, "agent", scope, cwd);
   if (!destDir) return null;
   const scopeRoot = scope === "user" ? homedir() : cwd;
-  return resolveContained(scopeRoot, relative(scopeRoot, destDir), `${slug}.md`);
+  return resolveContained(scopeRoot, relative(scopeRoot, destDir), subagentFileName(agent, slug));
 }
 async function installAgentForCodingAgent(item, agent, scope, method, force, cwd) {
   const spinner = ora(
@@ -269,8 +261,9 @@ async function getInstalledAgents(agent, scope, cwd = process.cwd()) {
   if (!destDir || !await exists(destDir)) {
     return [];
   }
+  const suffix = subagentFileName(agent, "");
   const files = await readdir(destDir);
-  return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+  return files.filter((file) => file.endsWith(suffix)).map((file) => file.slice(0, -suffix.length));
 }
 async function planAgent(item, agents, scope, method, cwd) {
   assertValidSlug(item.slug, SLUG_LABEL);
@@ -413,60 +406,11 @@ var commandHandler = {
 };
 
 // src/handlers/hook.ts
-import { join as join3, basename, dirname as dirname2 } from "path";
+import { join as join3, basename, dirname } from "path";
 import { homedir as homedir3 } from "os";
-import { lstat as lstat3, mkdir, mkdtemp, readFile as readFile2, realpath, rm, unlink as unlink3 } from "fs/promises";
+import { lstat as lstat3, mkdir, mkdtemp, readFile, realpath, rm, unlink as unlink3 } from "fs/promises";
 import chalk4 from "chalk";
 import ora3 from "ora";
-
-// src/utils/json.ts
-import { readFile, stat } from "fs/promises";
-import { dirname } from "path";
-async function readJson(path) {
-  try {
-    const content = await readFile(path, "utf-8");
-    return JSON.parse(content);
-  } catch (error2) {
-    if (error2.code === "ENOENT") {
-      return {};
-    }
-    if (error2 instanceof SyntaxError) {
-      throw new Error(`${path} is not valid JSON: ${error2.message}`, { cause: error2 });
-    }
-    throw error2;
-  }
-}
-async function existingFileMode(path) {
-  try {
-    return (await stat(path)).mode & 511;
-  } catch (error2) {
-    if (error2.code === "ENOENT") return void 0;
-    throw error2;
-  }
-}
-async function writeJson(path, data) {
-  await ensureDir(dirname(path));
-  const mode = await existingFileMode(path);
-  await writeFileAtomic(path, JSON.stringify(data, null, 2) + "\n", { mode });
-}
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    const sourceValue = source[key];
-    const targetValue = result[key];
-    if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
-      result[key] = deepMerge(
-        targetValue,
-        sourceValue
-      );
-    } else if (sourceValue !== void 0) {
-      result[key] = sourceValue;
-    }
-  }
-  return result;
-}
-
-// src/handlers/hook.ts
 var CLAUDE_ONLY_ERROR = "Hooks are only supported for Claude Code";
 var SCRIPT_NAME_LABEL = "hook script name";
 var SCRIPT_MODE = 493;
@@ -474,7 +418,7 @@ function getScopeRoot(scope, cwd) {
   return scope === "user" ? homedir3() : cwd;
 }
 function getHooksDir(scope, cwd) {
-  return join3(getScopeRoot(scope, cwd), ".claude", "hooks");
+  return scope === "user" ? join3(claudeUserRoot(), "hooks") : join3(getScopeRoot(scope, cwd), ".claude", "hooks");
 }
 function getScriptPath(scope, scriptName) {
   switch (scope) {
@@ -520,13 +464,13 @@ async function assertRegularFileOrMissing(path) {
 async function loadScriptBytes(item, scriptFile, hooksDir) {
   const sourcePath = getItemSourcePath(item);
   if (sourcePath && await exists(sourcePath)) {
-    return readFile2(join3(sourcePath, scriptFile));
+    return readFile(join3(sourcePath, scriptFile));
   }
-  const fetchDir = await mkdtemp(join3(dirname2(hooksDir), ".seedr-hook-"));
+  const fetchDir = await mkdtemp(join3(dirname(hooksDir), ".seedr-hook-"));
   try {
     const contentDir = join3(fetchDir, "content");
     await fetchItemToDestination(item, contentDir);
-    return await readFile2(join3(contentDir, scriptFile));
+    return await readFile(join3(contentDir, scriptFile));
   } finally {
     await rm(fetchDir, { recursive: true, force: true });
   }
@@ -703,6 +647,7 @@ async function planHook(item, agents, scope, _method, cwd) {
 }
 var hookHandler = {
   type: "hook",
+  honoursMethod: false,
   async install(item, agents, scope, method, force, cwd) {
     return installHook(item, agents, scope, method, force, cwd);
   },
@@ -716,8 +661,8 @@ var hookHandler = {
 };
 
 // src/handlers/mcp.ts
-import { readFile as readFile3 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 import chalk5 from "chalk";
 import ora4 from "ora";
 
@@ -1014,7 +959,7 @@ function jsonAdapter(agent, key, translate, defaults = {}) {
 }
 async function readTextOrEmpty(path) {
   try {
-    return await readFile3(path, "utf-8");
+    return await readFile2(path, "utf-8");
   } catch (error2) {
     if (error2.code === "ENOENT") return "";
     throw error2;
@@ -1028,7 +973,7 @@ var codexAdapter = {
   },
   async write(path, name, config) {
     const text = await readTextOrEmpty(path);
-    await ensureDir(dirname3(path));
+    await ensureDir(dirname2(path));
     await writeFileAtomic(path, upsertTomlTables(text, [CODEX_TABLE, name], toCodexTables(name, config)));
   },
   async remove(path, name) {
@@ -1044,7 +989,10 @@ var codexAdapter = {
 var ADAPTERS = {
   claude: jsonAdapter("claude", MCP_SERVERS_KEY, (config) => ({ ...config })),
   opencode: jsonAdapter("opencode", "mcp", toOpenCodeServer, { $schema: "https://opencode.ai/config.json" }),
-  codex: codexAdapter
+  codex: codexAdapter,
+  // Copilot reads the same `mcpServers` map Claude does — verified from
+  // `copilot mcp --help` and from a populated `~/.copilot/mcp-config.json`.
+  copilot: jsonAdapter("copilot", MCP_SERVERS_KEY, (config) => ({ ...config }))
 };
 function adapterFor(agent) {
   const adapter = ADAPTERS[agent];
@@ -1129,6 +1077,7 @@ async function planMcp(item, agents, scope, _method, cwd) {
 }
 var mcpHandler = {
   type: "mcp",
+  honoursMethod: false,
   async install(item, agents, scope, method, force, cwd) {
     return installMcp(item, agents, scope, method, force, cwd);
   },
@@ -1255,6 +1204,7 @@ async function planSettings(item, agents, scope, _method, cwd) {
 }
 var settingsHandler = {
   type: "settings",
+  honoursMethod: false,
   async install(item, agents, scope, method, force, cwd) {
     return installSettings(item, agents, scope, method, force, cwd);
   },
@@ -1268,23 +1218,30 @@ var settingsHandler = {
 };
 
 // src/handlers/plugin.ts
+import { join as join5, relative as relative3 } from "path";
+import { mkdir as mkdir3, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import chalk7 from "chalk";
+import ora6 from "ora";
+
+// src/handlers/pluginStores.ts
 import { homedir as homedir4 } from "os";
-import { join as join4, relative as relative3 } from "path";
-import { mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { join as join4 } from "path";
+import { mkdir as mkdir2, readFile as readFile3, writeFile } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import chalk7 from "chalk";
-import ora6 from "ora";
 var home = homedir4();
-var PLUGINS_DIR = join4(home, ".claude", "plugins");
-var PLUGINS_CACHE_DIR = join4(PLUGINS_DIR, "cache");
-var INSTALLED_PLUGINS_PATH = join4(PLUGINS_DIR, "installed_plugins.json");
-var KNOWN_MARKETPLACES_PATH = join4(PLUGINS_DIR, "known_marketplaces.json");
-var MARKETPLACES_DIR = join4(PLUGINS_DIR, "marketplaces");
-var PLUGIN_JSON_PATH = ".claude-plugin/plugin.json";
-var CLAUDE_ONLY_ERROR3 = "Plugins are only supported for Claude Code";
-var SLUG_LABEL3 = "plugin slug";
-var GITHUB_REPO_SLUG_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+var CLAUDE_MANIFEST = ".claude-plugin/plugin.json";
+async function readTextOrEmpty2(path) {
+  try {
+    return await readFile3(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function writeText(path, text) {
+  await mkdir2(join4(path, ".."), { recursive: true });
+  await writeFile(path, text, "utf-8");
+}
 function getPluginId(name, marketplace) {
   return `${name}@${marketplace}`;
 }
@@ -1293,6 +1250,420 @@ function splitPluginId(pluginId) {
   if (at <= 0 || at === pluginId.length - 1) return null;
   return { name: pluginId.slice(0, at), marketplace: pluginId.slice(at + 1) };
 }
+function manifestsFor(ownManifest) {
+  return ownManifest ? [ownManifest, CLAUDE_MANIFEST] : [CLAUDE_MANIFEST];
+}
+var CLAUDE_PLUGINS_DIR = join4(claudeUserRoot(), "plugins");
+var CLAUDE_CACHE_DIR = join4(CLAUDE_PLUGINS_DIR, "cache");
+var CLAUDE_INSTALLED_PATH = join4(CLAUDE_PLUGINS_DIR, "installed_plugins.json");
+var CLAUDE_KNOWN_MARKETPLACES_PATH = join4(CLAUDE_PLUGINS_DIR, "known_marketplaces.json");
+var CLAUDE_MARKETPLACES_DIR = join4(CLAUDE_PLUGINS_DIR, "marketplaces");
+function isScopeEntry(entry, scope, cwd) {
+  return entry.scope === scope && (scope === "user" || entry.projectPath === cwd);
+}
+async function enableInJsonSettings(path, pluginId) {
+  const settings = await readJson(path);
+  settings.enabledPlugins = settings.enabledPlugins || {};
+  settings.enabledPlugins[pluginId] = true;
+  await writeJson(path, settings);
+}
+async function disableInJsonSettings(path, pluginId) {
+  const settings = await readJson(path);
+  if (!settings.enabledPlugins || !(pluginId in settings.enabledPlugins)) return false;
+  delete settings.enabledPlugins[pluginId];
+  await writeJson(path, settings);
+  return true;
+}
+var claudeStore = {
+  manifestPaths: manifestsFor(),
+  userGlobal: false,
+  cacheRoot: CLAUDE_CACHE_DIR,
+  cachePath: (marketplace, name, version) => resolveContained(CLAUDE_CACHE_DIR, marketplace, name, version),
+  /**
+   * Claude Code reports a plugin as "orphaned" unless its marketplace is both
+   * recorded and cloned, so this is the one store that fetches a second
+   * repository. The other agents only record the source.
+   */
+  async ensureMarketplace(marketplace, item) {
+    const known = await readJson(CLAUDE_KNOWN_MARKETPLACES_PATH);
+    if (known[marketplace]) return [];
+    const repo = marketplaceRepo(item);
+    if (!repo) return [];
+    const installLocation = await resolveContained(CLAUDE_MARKETPLACES_DIR, marketplace);
+    const alreadyCloned = await exists(installLocation);
+    return [
+      {
+        path: CLAUDE_KNOWN_MARKETPLACES_PATH,
+        detail: `marketplace "${marketplace}"`,
+        ...alreadyCloned ? {} : {
+          creates: {
+            path: installLocation,
+            detail: `git clone https://github.com/${repo}.git`
+          }
+        },
+        apply: async () => {
+          await mkdir2(CLAUDE_MARKETPLACES_DIR, { recursive: true });
+          if (!await exists(installLocation)) {
+            await promisify(execFile)("git", [
+              "clone",
+              "--depth",
+              "1",
+              `https://github.com/${repo}.git`,
+              installLocation
+            ]);
+          }
+          const current = await readJson(
+            CLAUDE_KNOWN_MARKETPLACES_PATH
+          );
+          current[marketplace] = {
+            source: { source: "github", repo },
+            installLocation,
+            lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await writeJson(CLAUDE_KNOWN_MARKETPLACES_PATH, current);
+        }
+      }
+    ];
+  },
+  mutations: (context) => [
+    {
+      path: CLAUDE_INSTALLED_PATH,
+      detail: `plugins["${context.pluginId}"] entry for ${context.scope} scope`,
+      apply: async () => {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const registry = await readJson(CLAUDE_INSTALLED_PATH);
+        registry.version = registry.version || 2;
+        registry.plugins = registry.plugins || {};
+        const entry = {
+          scope: context.scope,
+          ...context.scope !== "user" ? { projectPath: context.cwd } : {},
+          installPath: context.cachePath ?? "",
+          version: context.version,
+          installedAt: now,
+          lastUpdated: now,
+          gitCommitSha: context.gitCommitSha
+        };
+        const existing = registry.plugins[context.pluginId] || [];
+        registry.plugins[context.pluginId] = [
+          ...existing.filter((candidate) => !isScopeEntry(candidate, context.scope, context.cwd)),
+          entry
+        ];
+        await writeJson(CLAUDE_INSTALLED_PATH, registry);
+      }
+    },
+    {
+      path: getSettingsPath(context.scope, context.cwd),
+      detail: `enabledPlugins["${context.pluginId}"] = true`,
+      apply: () => enableInJsonSettings(getSettingsPath(context.scope, context.cwd), context.pluginId)
+    }
+  ],
+  async listInstalled(scope, cwd) {
+    const registry = await readJson(CLAUDE_INSTALLED_PATH);
+    if (!registry.plugins) return [];
+    return Object.entries(registry.plugins).filter(([, entries]) => entries.some((entry) => isScopeEntry(entry, scope, cwd))).map(([pluginId]) => pluginId);
+  },
+  async remove(pluginId, scope, cwd) {
+    const registry = await readJson(CLAUDE_INSTALLED_PATH);
+    if (!registry.plugins?.[pluginId]) return false;
+    const entries = registry.plugins[pluginId];
+    const removed = entries.filter((entry) => isScopeEntry(entry, scope, cwd));
+    if (removed.length === 0) return false;
+    const remaining = entries.filter((entry) => !isScopeEntry(entry, scope, cwd));
+    if (remaining.length === 0) delete registry.plugins[pluginId];
+    else registry.plugins[pluginId] = remaining;
+    await writeJson(CLAUDE_INSTALLED_PATH, registry);
+    await disableInJsonSettings(getSettingsPath(scope, cwd), pluginId);
+    for (const installPath of new Set(removed.map((entry) => entry.installPath))) {
+      const stillUsed = Object.values(registry.plugins).some(
+        (list) => list.some((entry) => entry.installPath === installPath)
+      );
+      if (stillUsed || installPath === "") continue;
+      try {
+        await removePathEntry(await resolveContained(CLAUDE_CACHE_DIR, installPath));
+      } catch {
+      }
+    }
+    return true;
+  }
+};
+var COPILOT_DIR = copilotUserRoot();
+var COPILOT_SETTINGS_PATH = join4(COPILOT_DIR, "settings.json");
+var COPILOT_PLUGINS_DIR = join4(COPILOT_DIR, "installed-plugins");
+var copilotStore = {
+  manifestPaths: manifestsFor(),
+  userGlobal: true,
+  cacheRoot: COPILOT_PLUGINS_DIR,
+  cachePath: (marketplace, name) => resolveContained(COPILOT_PLUGINS_DIR, marketplace, name),
+  async ensureMarketplace(marketplace, item) {
+    const repo = marketplaceRepo(item);
+    if (!repo) return [];
+    const settings = await readJson(COPILOT_SETTINGS_PATH);
+    if (settings.extraKnownMarketplaces?.[marketplace]) return [];
+    return [
+      {
+        path: COPILOT_SETTINGS_PATH,
+        detail: `extraKnownMarketplaces["${marketplace}"] = ${repo}`,
+        apply: async () => {
+          const current = await readJson(COPILOT_SETTINGS_PATH);
+          current.extraKnownMarketplaces = current.extraKnownMarketplaces || {};
+          current.extraKnownMarketplaces[marketplace] = { source: { source: "github", repo } };
+          await writeJson(COPILOT_SETTINGS_PATH, current);
+        }
+      }
+    ];
+  },
+  mutations: (context) => [
+    {
+      path: COPILOT_SETTINGS_PATH,
+      detail: `enabledPlugins["${context.pluginId}"] = true`,
+      apply: () => enableInJsonSettings(COPILOT_SETTINGS_PATH, context.pluginId)
+    }
+  ],
+  async listInstalled() {
+    const settings = await readJson(COPILOT_SETTINGS_PATH);
+    return Object.entries(settings.enabledPlugins || {}).filter(([, enabled]) => enabled).map(([pluginId]) => pluginId);
+  },
+  async remove(pluginId) {
+    const disabled = await disableInJsonSettings(COPILOT_SETTINGS_PATH, pluginId);
+    if (!disabled) return false;
+    const split = splitPluginId(pluginId);
+    if (split) {
+      try {
+        await removePathEntry(await resolveContained(COPILOT_PLUGINS_DIR, split.marketplace, split.name));
+      } catch {
+      }
+    }
+    return true;
+  }
+};
+var CODEX_DIR = codexUserRoot();
+var CODEX_CONFIG_PATH = join4(CODEX_DIR, "config.toml");
+var CODEX_CACHE_DIR = join4(CODEX_DIR, "plugins", "cache");
+function toCodexMarketplaceTable(marketplace, url, revision) {
+  return {
+    keyPath: ["marketplaces", marketplace],
+    entries: {
+      source_type: "git",
+      source: url,
+      ...revision ? { last_revision: revision } : {},
+      last_updated: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function toCodexPluginTable(pluginId) {
+  return { keyPath: ["plugins", pluginId], entries: { enabled: true } };
+}
+async function upsertCodex(table) {
+  const text = await readTextOrEmpty2(CODEX_CONFIG_PATH);
+  await writeText(CODEX_CONFIG_PATH, upsertTomlTables(text, table.keyPath, [table]));
+}
+var codexStore = {
+  manifestPaths: manifestsFor(".codex-plugin/plugin.json"),
+  userGlobal: true,
+  cacheRoot: CODEX_CACHE_DIR,
+  // Real cache entries on disk are <marketplace>/<name>/<version> — e.g.
+  // claude-plugins-official/claude-code-setup/1.0.0. Dropping the version
+  // segment writes a tree Codex does not look in.
+  cachePath: (marketplace, name, version) => resolveContained(CODEX_CACHE_DIR, marketplace, name, version),
+  async ensureMarketplace(marketplace, item) {
+    const repo = marketplaceRepo(item);
+    if (!repo) return [];
+    const url = `https://github.com/${repo}.git`;
+    return [
+      {
+        path: CODEX_CONFIG_PATH,
+        detail: `[marketplaces.${marketplace}] source = "${url}"`,
+        apply: () => upsertCodex(toCodexMarketplaceTable(marketplace, url, getEffectiveSourceRevision(item) ?? void 0))
+      }
+    ];
+  },
+  mutations: (context) => [
+    {
+      path: CODEX_CONFIG_PATH,
+      detail: `[plugins."${context.pluginId}"] enabled = true`,
+      apply: () => upsertCodex(toCodexPluginTable(context.pluginId))
+    }
+  ],
+  async listInstalled() {
+    const text = await readTextOrEmpty2(CODEX_CONFIG_PATH);
+    const ids = [];
+    for (const match of text.matchAll(/^\[plugins\."([^"]+)"\]/gm)) {
+      if (match[1]) ids.push(match[1]);
+    }
+    return ids;
+  },
+  async remove(pluginId) {
+    const text = await readTextOrEmpty2(CODEX_CONFIG_PATH);
+    const { text: next, removed } = removeTomlTables(text, ["plugins", pluginId]);
+    if (!removed) return false;
+    await writeText(CODEX_CONFIG_PATH, next);
+    const split = splitPluginId(pluginId);
+    if (split) {
+      try {
+        await removePathEntry(await resolveContained(CODEX_CACHE_DIR, split.marketplace, split.name));
+      } catch {
+      }
+    }
+    return true;
+  }
+};
+function openCodeConfigPath(scope, cwd) {
+  return scope === "user" ? join4(openCodeUserConfigDir(), "opencode.json") : join4(cwd, "opencode.json");
+}
+function toOpenCodePluginSpec(item, name) {
+  const source = item.pluginSource;
+  if (source?.path) {
+    throw new Error(
+      `OpenCode cannot install "${name}": its content is the subdirectory "${source.path}" of ${source.url ?? "its repository"}, and an OpenCode plugin spec cannot name a subdirectory`
+    );
+  }
+  const repo = githubRepoOf(source?.url) ?? githubRepoOf(item.externalUrl);
+  if (!repo) return name;
+  const pinned = source?.sha ?? item.sourceRevision;
+  return `${name}@git+https://github.com/${repo}.git${pinned ? `#${pinned}` : ""}`;
+}
+function specName(spec) {
+  const at = spec.indexOf("@", 1);
+  return at > 0 ? spec.slice(0, at) : spec;
+}
+var openCodeStore = {
+  manifestPaths: manifestsFor(),
+  userGlobal: false,
+  cacheRoot: null,
+  // OpenCode installs the module from the spec; seedr writes no tree.
+  cachePath: async () => null,
+  mutations: (context) => {
+    const path = openCodeConfigPath(context.scope, context.cwd);
+    const spec = toOpenCodePluginSpec(context.item, context.name);
+    return [
+      {
+        path,
+        detail: `plugin[] += "${spec}"`,
+        apply: async () => {
+          const config = await readJson(path);
+          config.$schema = config.$schema || "https://opencode.ai/config.json";
+          const plugins = config.plugin || [];
+          config.plugin = [...plugins.filter((entry) => specName(entry) !== context.name), spec];
+          await writeJson(path, config);
+        }
+      }
+    ];
+  },
+  async listInstalled(scope, cwd) {
+    const config = await readJson(openCodeConfigPath(scope, cwd));
+    return (config.plugin || []).map(specName);
+  },
+  async remove(pluginId, scope, cwd) {
+    const path = openCodeConfigPath(scope, cwd);
+    const config = await readJson(path);
+    const name = splitPluginId(pluginId)?.name ?? pluginId;
+    const plugins = config.plugin || [];
+    const remaining = plugins.filter((entry) => specName(entry) !== name);
+    if (remaining.length === plugins.length) return false;
+    config.plugin = remaining;
+    await writeJson(path, config);
+    return true;
+  }
+};
+var GEMINI_CONFIG_DIR = join4(home, ".gemini", "config");
+var GEMINI_PLUGINS_DIR = join4(GEMINI_CONFIG_DIR, "plugins");
+var GEMINI_IMPORT_MANIFEST_PATH = join4(GEMINI_CONFIG_DIR, "import_manifest.json");
+var antigravityStore = {
+  manifestPaths: manifestsFor(),
+  userGlobal: true,
+  cacheRoot: GEMINI_PLUGINS_DIR,
+  // Antigravity files plugins by name only — it has no marketplace dimension.
+  cachePath: (_marketplace, name) => resolveContained(GEMINI_PLUGINS_DIR, name),
+  /**
+   * Antigravity discovers a plugin by a `plugin.json` at the tree ROOT, and
+   * `.claude-plugin/plugin.json` is not a substitute: the cross-tool matrix
+   * marks it a migration path (`agy plugin import claude`), never a reader.
+   * `agy plugin validate` on a Claude-manifest-only tree answers
+   * "missing plugin.json"; with a root manifest it answers "skills: 1 processed".
+   *
+   * Most plugins in the wild ship only the Claude manifest, so without this the
+   * install lands a directory Antigravity refuses — reporting success while the
+   * plugin does nothing. A tree that already carries its own root manifest
+   * (compound-engineering does) is left exactly as it is.
+   */
+  async prepareTree(contentPath, { name, version, item }) {
+    const manifestPath = join4(contentPath, "plugin.json");
+    if (await exists(manifestPath)) return;
+    await writeJson(manifestPath, {
+      name,
+      version,
+      ...item.description ? { description: item.description } : {}
+    });
+  },
+  mutations: (context) => [
+    {
+      path: GEMINI_IMPORT_MANIFEST_PATH,
+      detail: `imports[] += "${context.name}"`,
+      apply: async () => {
+        const manifest = await readJson(GEMINI_IMPORT_MANIFEST_PATH);
+        const imports = manifest.imports || [];
+        manifest.imports = [
+          ...imports.filter((entry) => entry.name !== context.name),
+          {
+            name: context.name,
+            source: "seedr",
+            importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            components: ["skills", "hooks"]
+          }
+        ];
+        await writeJson(GEMINI_IMPORT_MANIFEST_PATH, manifest);
+      }
+    }
+  ],
+  async listInstalled() {
+    const manifest = await readJson(GEMINI_IMPORT_MANIFEST_PATH);
+    return (manifest.imports || []).map((entry) => entry.name);
+  },
+  async remove(pluginId) {
+    const name = splitPluginId(pluginId)?.name ?? pluginId;
+    const manifest = await readJson(GEMINI_IMPORT_MANIFEST_PATH);
+    const imports = manifest.imports || [];
+    const remaining = imports.filter((entry) => entry.name !== name);
+    if (remaining.length === imports.length) return false;
+    manifest.imports = remaining;
+    await writeJson(GEMINI_IMPORT_MANIFEST_PATH, manifest);
+    try {
+      await removePathEntry(await resolveContained(GEMINI_PLUGINS_DIR, name));
+    } catch {
+    }
+    return true;
+  }
+};
+var GITHUB_REPO_SLUG_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function githubRepoOf(url) {
+  if (!url) return null;
+  const parsed = parseGitHubRepo(url);
+  if (!parsed) return null;
+  const repo = `${parsed.owner}/${parsed.repo}`;
+  if (!GITHUB_REPO_SLUG_PATTERN.test(repo) || repo.includes("..")) return null;
+  return repo;
+}
+function marketplaceRepo(item) {
+  return githubRepoOf(item.marketplaceRef?.url ?? item.externalUrl);
+}
+var STORES = {
+  claude: claudeStore,
+  copilot: copilotStore,
+  codex: codexStore,
+  opencode: openCodeStore,
+  antigravity: antigravityStore,
+  gemini: antigravityStore
+};
+function pluginStoreFor(agent) {
+  const store = STORES[canonicalAgent(agent) ?? agent];
+  if (!store || !isTypeSupported("plugin", agent)) {
+    throw new Error(`Plugins are not supported for ${CODING_AGENTS[agent]?.name ?? agent}`);
+  }
+  return store;
+}
+
+// src/handlers/plugin.ts
+var SLUG_LABEL3 = "plugin slug";
 function resolveMarketplaceName(item) {
   const marketplace = item.marketplace || item.author?.name || "seedr";
   assertSafePathSegment(marketplace, "plugin marketplace");
@@ -1305,48 +1676,29 @@ function resolvePluginIdentity(item, pluginJson) {
   assertSafePathSegment(version, "plugin version");
   return { name, version };
 }
-function extractGitHubRepo(url) {
-  const parsed = parseGitHubRepo(url);
-  if (!parsed) return null;
-  const slug = `${parsed.owner}/${parsed.repo}`;
-  if (!GITHUB_REPO_SLUG_PATTERN.test(slug) || slug.includes("..")) return null;
-  return slug;
-}
-function marketplaceRepoUrl(item) {
-  return item.marketplaceRef?.url ?? item.externalUrl;
+async function readManifestFromDir(dir, manifestPaths) {
+  for (const manifest of manifestPaths) {
+    const path = join5(dir, ...manifest.split("/"));
+    if (await exists(path)) return readJson(path);
+  }
+  return {};
 }
-async function ensureMarketplaceRegistered(marketplace, item) {
-  const known = await readJson(
-    KNOWN_MARKETPLACES_PATH
-  );
-  if (known[marketplace]) return;
-  const sourceUrl = marketplaceRepoUrl(item);
-  const repo = sourceUrl ? extractGitHubRepo(sourceUrl) : null;
-  if (!repo) return;
-  const installLocation = await resolveContained(MARKETPLACES_DIR, marketplace);
-  await mkdir2(MARKETPLACES_DIR, { recursive: true });
-  if (!await exists(installLocation)) {
-    const execFileAsync = promisify(execFile);
-    await execFileAsync("git", [
-      "clone",
-      "--depth",
-      "1",
-      `https://github.com/${repo}.git`,
-      installLocation
-    ]);
-  }
-  known[marketplace] = {
-    source: { source: "github", repo },
-    installLocation,
-    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await writeJson(KNOWN_MARKETPLACES_PATH, known);
+async function readManifestForPlan(item, manifestPaths) {
+  const sourcePath = getItemSourcePath(item);
+  if (sourcePath) return readManifestFromDir(sourcePath, manifestPaths);
+  for (const manifest of manifestPaths) {
+    try {
+      return JSON.parse(await fetchItemFile(item, manifest));
+    } catch {
+    }
+  }
+  return {};
 }
-async function createStagingDir(slug) {
-  const tmpRoot = await resolveContained(PLUGINS_CACHE_DIR, ".tmp");
-  await mkdir2(tmpRoot, { recursive: true });
-  const staging = await mkdtemp2(join4(tmpRoot, `${slug}-`));
-  return resolveContained(PLUGINS_CACHE_DIR, relative3(PLUGINS_CACHE_DIR, staging));
+async function createStagingDir(cacheRoot, slug) {
+  const tmpRoot = await resolveContained(cacheRoot, ".tmp");
+  await mkdir3(tmpRoot, { recursive: true });
+  const staging = await mkdtemp2(join5(tmpRoot, `${slug}-`));
+  return resolveContained(cacheRoot, relative3(cacheRoot, staging));
 }
 async function stageContent(item, contentPath) {
   const sourcePath = getItemSourcePath(item);
@@ -1365,37 +1717,6 @@ function resolveGitCommitSha(item, fetched) {
   }
   return sha;
 }
-function isScopeEntry(entry, scope, cwd) {
-  return entry.scope === scope && (scope === "user" || entry.projectPath === cwd);
-}
-async function writeInstalledEntry(params) {
-  const { cachePath, pluginId, version, gitCommitSha, scope, cwd } = params;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const registry = await readJson(INSTALLED_PLUGINS_PATH);
-  registry.version = registry.version || 2;
-  registry.plugins = registry.plugins || {};
-  const installInfo = {
-    scope,
-    ...scope !== "user" ? { projectPath: cwd } : {},
-    installPath: cachePath,
-    version,
-    installedAt: now,
-    lastUpdated: now,
-    gitCommitSha
-  };
-  const existingEntries = registry.plugins[pluginId] || [];
-  registry.plugins[pluginId] = [
-    ...existingEntries.filter((entry) => !isScopeEntry(entry, scope, cwd)),
-    installInfo
-  ];
-  await writeJson(INSTALLED_PLUGINS_PATH, registry);
-}
-async function enableInSettings(settingsPath, pluginId) {
-  const settings = await readJson(settingsPath);
-  settings.enabledPlugins = settings.enabledPlugins || {};
-  settings.enabledPlugins[pluginId] = true;
-  await writeJson(settingsPath, settings);
-}
 async function rollback(undo, error2) {
   const failures = [];
   for (const step2 of undo.reverse()) {
@@ -1411,70 +1732,78 @@ async function rollback(undo, error2) {
   }
   throw error2;
 }
-async function commitInstall(params) {
-  const { contentPath, cachePath, pluginId, scope, cwd } = params;
+async function commitInstall(contentPath, cachePath, mutations) {
   const undo = [];
   try {
-    await removePathEntry(cachePath);
-    await moveDirectory(contentPath, cachePath);
-    undo.push(() => removePathEntry(cachePath).then(() => void 0));
-    const registrySnapshot = await snapshotFile(INSTALLED_PLUGINS_PATH);
-    await writeInstalledEntry(params);
-    undo.push(() => restoreFile(INSTALLED_PLUGINS_PATH, registrySnapshot));
-    const settingsPath = getSettingsPath(scope, cwd);
-    const settingsSnapshot = await snapshotFile(settingsPath);
-    await enableInSettings(settingsPath, pluginId);
-    undo.push(() => restoreFile(settingsPath, settingsSnapshot));
+    if (contentPath && cachePath) {
+      await removePathEntry(cachePath);
+      await moveDirectory(contentPath, cachePath);
+      undo.push(() => removePathEntry(cachePath).then(() => void 0));
+    }
+    for (const mutation of mutations) {
+      const snapshot = await snapshotFile(mutation.path);
+      await mutation.apply();
+      undo.push(() => restoreFile(mutation.path, snapshot));
+    }
   } catch (error2) {
     await rollback(undo, error2);
   }
 }
 async function installPluginForAgent(item, agent, scope, _method, force, cwd) {
-  const spinner = ora6(
-    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
-  ).start();
+  const spinner = ora6(`Installing ${item.name} for ${CODING_AGENTS[agent].name}...`).start();
   try {
-    if (agent !== "claude") {
-      throw new Error(CLAUDE_ONLY_ERROR3);
-    }
+    const store = pluginStoreFor(agent);
     assertValidSlug(item.slug, SLUG_LABEL3);
     const marketplace = resolveMarketplaceName(item);
-    const staging = await createStagingDir(item.slug);
+    const cacheRoot = store.cacheRoot;
+    const staging = cacheRoot ? await createStagingDir(cacheRoot, item.slug) : null;
     try {
-      const contentPath = join4(staging, "content");
-      const fetched = await stageContent(item, contentPath);
-      const pluginJson = await readJson(join4(contentPath, ...PLUGIN_JSON_PATH.split("/")));
+      const contentPath = staging ? join5(staging, "content") : null;
+      const fetched = contentPath ? await stageContent(item, contentPath) : null;
+      const pluginJson = contentPath ? await readManifestFromDir(contentPath, store.manifestPaths) : await readManifestForPlan(item, store.manifestPaths);
       const { name, version } = resolvePluginIdentity(item, pluginJson);
+      if (contentPath && store.prepareTree) {
+        await store.prepareTree(contentPath, { name, version, item });
+      }
       const gitCommitSha = resolveGitCommitSha(item, fetched);
       const pluginId = getPluginId(name, marketplace);
-      await ensureMarketplaceRegistered(marketplace, item);
-      const cachePath = await resolveContained(PLUGINS_CACHE_DIR, marketplace, name, version);
-      await assertOverwritable(cachePath, force);
-      await commitInstall({ contentPath, cachePath, pluginId, version, gitCommitSha, scope, cwd });
-      spinner.succeed(
-        brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
-      );
-      return { agent, success: true, path: cachePath };
+      const cachePath = await store.cachePath(marketplace, name, version);
+      const marketplaceMutations = store.ensureMarketplace ? await store.ensureMarketplace(marketplace, item) : [];
+      const context = {
+        item,
+        marketplace,
+        name,
+        version,
+        pluginId,
+        cachePath,
+        gitCommitSha,
+        scope,
+        cwd
+      };
+      if (cachePath) await assertOverwritable(cachePath, force);
+      await commitInstall(contentPath, cachePath, [
+        ...marketplaceMutations,
+        ...store.mutations(context)
+      ]);
+      spinner.succeed(brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`));
+      return { agent, success: true, path: cachePath ?? "" };
     } finally {
-      await rm2(staging, { recursive: true, force: true });
+      if (staging) await rm2(staging, { recursive: true, force: true });
     }
   } catch (error2) {
     const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
-    spinner.fail(
-      chalk7.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
-    );
+    spinner.fail(chalk7.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`));
     return { agent, success: false, path: "", error: errorMsg };
   }
 }
 async function installPlugin(item, agents, scope, method, force, cwd = process.cwd()) {
   const results = [];
   for (const agent of agents) {
-    const result = await installPluginForAgent(item, agent, scope, method, force, cwd);
-    results.push(result);
+    results.push(await installPluginForAgent(item, agent, scope, method, force, cwd));
   }
   return results;
 }
-async function findInstalledPluginId(registry, slug) {
+async function findInstalledPluginId(installed, slug) {
   let registryMarketplace = null;
   try {
     const item = await getItem(slug, "plugin");
@@ -1484,70 +1813,34 @@ async function findInstalledPluginId(registry, slug) {
   }
   if (registryMarketplace !== null) {
     const exact = getPluginId(slug, registryMarketplace);
-    return exact in registry.plugins ? exact : null;
+    if (installed.includes(exact)) return exact;
+    return installed.includes(slug) ? slug : null;
   }
-  const candidates = Object.keys(registry.plugins).filter((id) => splitPluginId(id)?.name === slug);
+  const candidates = installed.filter((id) => (splitPluginId(id)?.name ?? id) === slug);
   return candidates.length === 1 ? candidates[0] : null;
 }
-async function removeOrphanedCache(installPath, registry) {
-  const stillReferenced = Object.values(registry.plugins).some(
-    (entries) => entries.some((entry) => entry.installPath === installPath)
-  );
-  if (stillReferenced) return;
-  let contained;
+async function uninstallPlugin(slug, agent, scope, cwd = process.cwd()) {
+  assertValidSlug(slug, SLUG_LABEL3);
+  let store;
   try {
-    contained = await resolveContained(PLUGINS_CACHE_DIR, installPath);
+    store = pluginStoreFor(agent);
   } catch {
-    return;
+    return false;
   }
-  await removePathEntry(contained);
-}
-async function uninstallPlugin(slug, agent, scope, cwd = process.cwd()) {
-  assertValidSlug(slug, SLUG_LABEL3);
-  if (agent !== "claude") return false;
-  const registry = await readJson(INSTALLED_PLUGINS_PATH);
-  if (!registry.plugins) return false;
-  const pluginId = await findInstalledPluginId(registry, slug);
+  const installed = await store.listInstalled(scope, cwd);
+  const pluginId = await findInstalledPluginId(installed, slug);
   if (!pluginId) return false;
-  const entries = registry.plugins[pluginId] || [];
-  const removedEntries = entries.filter((entry) => isScopeEntry(entry, scope, cwd));
-  if (removedEntries.length === 0) return false;
-  const remaining = entries.filter((entry) => !isScopeEntry(entry, scope, cwd));
-  if (remaining.length === 0) {
-    delete registry.plugins[pluginId];
-  } else {
-    registry.plugins[pluginId] = remaining;
-  }
-  await writeJson(INSTALLED_PLUGINS_PATH, registry);
-  const settingsPath = getSettingsPath(scope, cwd);
-  const settings = await readJson(settingsPath);
-  if (settings.enabledPlugins && pluginId in settings.enabledPlugins) {
-    delete settings.enabledPlugins[pluginId];
-    await writeJson(settingsPath, settings);
-  }
-  for (const installPath of new Set(removedEntries.map((entry) => entry.installPath))) {
-    await removeOrphanedCache(installPath, registry);
-  }
-  return true;
+  return store.remove(pluginId, scope, cwd);
 }
 async function getInstalledPlugins(agent, scope, cwd = process.cwd()) {
-  if (agent !== "claude") return [];
-  const registry = await readJson(INSTALLED_PLUGINS_PATH);
-  if (!registry.plugins) return [];
-  const installed = [];
-  for (const [pluginId, entries] of Object.entries(registry.plugins)) {
-    if (entries.some((entry) => isScopeEntry(entry, scope, cwd))) {
-      installed.push(splitPluginId(pluginId)?.name ?? pluginId);
-    }
-  }
-  return installed;
-}
-async function readPluginJsonForPlan(item) {
-  const sourcePath = getItemSourcePath(item);
-  if (sourcePath) {
-    return readJson(join4(sourcePath, ...PLUGIN_JSON_PATH.split("/")));
+  let store;
+  try {
+    store = pluginStoreFor(agent);
+  } catch {
+    return [];
   }
-  return JSON.parse(await fetchItemFile(item, PLUGIN_JSON_PATH));
+  const installed = await store.listInstalled(scope, cwd);
+  return installed.map((pluginId) => splitPluginId(pluginId)?.name ?? pluginId);
 }
 async function kindFor(path) {
   return await exists(path) ? "modify" : "create";
@@ -1555,40 +1848,53 @@ async function kindFor(path) {
 async function planPlugin(item, agents, scope, _method, cwd) {
   const changes = [];
   for (const agent of agents) {
-    if (agent !== "claude") throw new Error(CLAUDE_ONLY_ERROR3);
+    const store = pluginStoreFor(agent);
     assertValidSlug(item.slug, SLUG_LABEL3);
     const marketplace = resolveMarketplaceName(item);
-    const { name, version } = resolvePluginIdentity(item, await readPluginJsonForPlan(item));
+    const { name, version } = resolvePluginIdentity(
+      item,
+      await readManifestForPlan(item, store.manifestPaths)
+    );
     const pluginId = getPluginId(name, marketplace);
-    const cachePath = await resolveContained(PLUGINS_CACHE_DIR, marketplace, name, version);
-    const settingsPath = getSettingsPath(scope, cwd);
-    changes.push(
-      { agent, kind: await kindFor(cachePath), path: cachePath, detail: "plugin files (digest-verified download)" },
-      {
+    const cachePath = await store.cachePath(marketplace, name, version);
+    resolveGitCommitSha(item, null);
+    if (cachePath) {
+      changes.push({
         agent,
-        kind: await kindFor(INSTALLED_PLUGINS_PATH),
-        path: INSTALLED_PLUGINS_PATH,
-        detail: `plugins["${pluginId}"] entry for ${scope} scope`
-      }
-    );
-    const known = await readJson(KNOWN_MARKETPLACES_PATH);
-    if (!known[marketplace]) {
-      const sourceUrl = marketplaceRepoUrl(item);
-      const repo = sourceUrl ? extractGitHubRepo(sourceUrl) : null;
-      if (repo) {
-        const cloneDir = await resolveContained(MARKETPLACES_DIR, marketplace);
-        changes.push({ agent, kind: await kindFor(KNOWN_MARKETPLACES_PATH), path: KNOWN_MARKETPLACES_PATH, detail: `marketplace "${marketplace}"` });
-        if (!await exists(cloneDir)) {
-          changes.push({ agent, kind: "create", path: cloneDir, detail: `git clone https://github.com/${repo}.git` });
-        }
+        kind: await kindFor(cachePath),
+        path: cachePath,
+        detail: "plugin files (digest-verified download)"
+      });
+    }
+    const marketplaceMutations = store.ensureMarketplace ? await store.ensureMarketplace(marketplace, item) : [];
+    const context = {
+      item,
+      marketplace,
+      name,
+      version,
+      pluginId,
+      cachePath,
+      gitCommitSha: resolveGitCommitSha(item, null),
+      scope,
+      cwd
+    };
+    for (const mutation of [...marketplaceMutations, ...store.mutations(context)]) {
+      changes.push({
+        agent,
+        kind: await kindFor(mutation.path),
+        path: mutation.path,
+        detail: store.userGlobal ? `${mutation.detail} \u2014 user-global, ${CODING_AGENTS[agent].name} has no project-scoped plugin store` : mutation.detail
+      });
+      if (mutation.creates) {
+        changes.push({ agent, kind: "create", ...mutation.creates });
       }
     }
-    changes.push({ agent, kind: await kindFor(settingsPath), path: settingsPath, detail: `enabledPlugins["${pluginId}"] = true` });
   }
   return changes;
 }
 var pluginHandler = {
   type: "plugin",
+  honoursMethod: false,
   async install(item, agents, scope, method, force, cwd) {
     return installPlugin(item, agents, scope, method, force, cwd);
   },
@@ -1601,6 +1907,216 @@ var pluginHandler = {
   plan: planPlugin
 };
 
+// src/handlers/rule.ts
+import { dirname as dirname3 } from "path";
+import { readdir as readdir3, readFile as readFile4, writeFile as writeFile2, mkdir as mkdir4 } from "fs/promises";
+import chalk8 from "chalk";
+import ora7 from "ora";
+
+// src/handlers/ruleTargets.ts
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+var home2 = homedir5();
+var markdownFile = (slug) => `${slug}.md`;
+var claudeTarget = {
+  kind: "file",
+  dir: (scope, cwd) => join6(scope === "user" ? claudeUserRoot() : join6(cwd, ".claude"), "rules"),
+  fileName: markdownFile,
+  keepsFrontmatter: true
+};
+var antigravityTarget = {
+  kind: "file",
+  dir: (scope, cwd) => join6(scope === "user" ? join6(home2, ".gemini", "config") : join6(cwd, ".agents"), "rules"),
+  fileName: markdownFile,
+  keepsFrontmatter: true
+};
+var copilotTarget = {
+  kind: "file",
+  dir: (scope, cwd) => join6(scope === "user" ? copilotUserRoot() : join6(cwd, ".github"), "instructions"),
+  fileName: (slug) => `${slug}.instructions.md`,
+  keepsFrontmatter: true
+};
+var codexTarget = {
+  kind: "section",
+  file: (scope, cwd) => scope === "user" ? join6(codexUserRoot(), "AGENTS.md") : join6(cwd, "AGENTS.md")
+};
+var openCodeTarget = {
+  kind: "section",
+  file: (scope, cwd) => scope === "user" ? join6(openCodeUserConfigDir(), "AGENTS.md") : join6(cwd, "AGENTS.md")
+};
+var TARGETS = {
+  claude: claudeTarget,
+  antigravity: antigravityTarget,
+  gemini: antigravityTarget,
+  copilot: copilotTarget,
+  codex: codexTarget,
+  opencode: openCodeTarget
+};
+function ruleTargetFor(agent) {
+  const target = TARGETS[canonicalAgent(agent) ?? agent];
+  if (!target || !isTypeSupported("rule", agent)) {
+    throw new Error(`Rules are not supported for ${CODING_AGENTS[agent]?.name ?? agent}`);
+  }
+  return target;
+}
+var sectionStart = (slug) => `<!-- seedr:rule:${slug} -->`;
+var sectionEnd = (slug) => `<!-- /seedr:rule:${slug} -->`;
+function sectionPattern(slug) {
+  const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\n*<!-- seedr:rule:${escaped} -->[\\s\\S]*?<!-- /seedr:rule:${escaped} -->\\n*`, "g");
+}
+function stripFrontmatter(content) {
+  const match = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/.exec(content);
+  return match ? content.slice(match[0].length) : content;
+}
+function upsertSection(document, slug, content) {
+  const block = `${sectionStart(slug)}
+${stripFrontmatter(content).trim()}
+${sectionEnd(slug)}`;
+  const existing = sectionPattern(slug);
+  if (existing.test(document)) {
+    return document.replace(sectionPattern(slug), `
+
+${block}
+`);
+  }
+  const base = document.trimEnd();
+  return base.length > 0 ? `${base}
+
+${block}
+` : `${block}
+`;
+}
+function removeSection(document, slug) {
+  if (!sectionPattern(slug).test(document)) return null;
+  const stripped = document.replace(sectionPattern(slug), "\n\n").trimEnd();
+  return stripped.length > 0 ? `${stripped}
+` : "";
+}
+function listSections(document) {
+  return [...document.matchAll(/<!-- seedr:rule:([^\s>]+) -->/g)].map((match) => match[1]);
+}
+
+// src/handlers/rule.ts
+var SLUG_LABEL4 = "rule slug";
+var RULE_FILE = "rule.md";
+async function readTextOrEmpty3(path) {
+  try {
+    return await readFile4(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function readRuleContent(item) {
+  const sourcePath = getItemSourcePath(item);
+  if (sourcePath) {
+    const local = await readTextOrEmpty3(`${sourcePath}/${RULE_FILE}`);
+    if (local) return local;
+  }
+  return fetchItemFile(item, RULE_FILE);
+}
+async function destinationFor(target, slug, scope, cwd) {
+  if (target.kind === "section") return target.file(scope, cwd);
+  const dir = target.dir(scope, cwd);
+  return resolveContained(dir, target.fileName(slug));
+}
+async function installRuleForAgent(item, agent, scope, force, cwd, content) {
+  const spinner = ora7(`Installing ${item.name} for ${CODING_AGENTS[agent].name}...`).start();
+  try {
+    const target = ruleTargetFor(agent);
+    const destination = await destinationFor(target, item.slug, scope, cwd);
+    await mkdir4(dirname3(destination), { recursive: true });
+    if (target.kind === "file") {
+      await assertOverwritable(destination, force);
+      await writeFile2(
+        destination,
+        target.keepsFrontmatter ? content : stripFrontmatter(content),
+        "utf-8"
+      );
+    } else {
+      const document = await readTextOrEmpty3(destination);
+      await writeFile2(destination, upsertSection(document, item.slug, content), "utf-8");
+    }
+    spinner.succeed(brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`));
+    return { agent, success: true, path: destination };
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : "Unknown error";
+    spinner.fail(chalk8.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${message}`));
+    return { agent, success: false, path: "", error: message };
+  }
+}
+async function installRule(item, agents, scope, _method, force, cwd = process.cwd()) {
+  assertValidSlug(item.slug, SLUG_LABEL4);
+  const content = await readRuleContent(item);
+  const results = [];
+  for (const agent of agents) {
+    results.push(await installRuleForAgent(item, agent, scope, force, cwd, content));
+  }
+  return results;
+}
+async function uninstallRule(slug, agent, scope, cwd = process.cwd()) {
+  assertValidSlug(slug, SLUG_LABEL4);
+  let target;
+  try {
+    target = ruleTargetFor(agent);
+  } catch {
+    return false;
+  }
+  const destination = await destinationFor(target, slug, scope, cwd);
+  if (target.kind === "file") return removePathEntry(destination);
+  const document = await readTextOrEmpty3(destination);
+  const stripped = removeSection(document, slug);
+  if (stripped === null) return false;
+  await writeFile2(destination, stripped, "utf-8");
+  return true;
+}
+async function getInstalledRules(agent, scope, cwd = process.cwd()) {
+  let target;
+  try {
+    target = ruleTargetFor(agent);
+  } catch {
+    return [];
+  }
+  if (target.kind === "section") {
+    return listSections(await readTextOrEmpty3(target.file(scope, cwd)));
+  }
+  const dir = target.dir(scope, cwd);
+  if (!await exists(dir)) return [];
+  const suffix = target.fileName("");
+  const entries = await readdir3(dir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(suffix) && !entry.name.startsWith(".")).map((entry) => entry.name.slice(0, -suffix.length));
+}
+async function planRule(item, agents, scope, _method, cwd) {
+  assertValidSlug(item.slug, SLUG_LABEL4);
+  const changes = [];
+  for (const agent of agents) {
+    const target = ruleTargetFor(agent);
+    const destination = await destinationFor(target, item.slug, scope, cwd);
+    const present = await exists(destination);
+    changes.push({
+      agent,
+      kind: present ? "modify" : "create",
+      path: destination,
+      detail: target.kind === "file" ? "rule file" : `merged section <!-- seedr:rule:${item.slug} --> (the rest of the file is untouched)`
+    });
+  }
+  return changes;
+}
+var ruleHandler = {
+  type: "rule",
+  honoursMethod: false,
+  async install(item, agents, scope, method, force, cwd) {
+    return installRule(item, agents, scope, method, force, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallRule(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledRules(agent, scope, cwd);
+  },
+  plan: planRule
+};
+
 // src/handlers/index.ts
 registerHandler(skillHandler);
 registerHandler(agentHandler);
@@ -1609,6 +2125,7 @@ registerHandler(hookHandler);
 registerHandler(mcpHandler);
 registerHandler(settingsHandler);
 registerHandler(pluginHandler);
+registerHandler(ruleHandler);
 
 // src/commands/add.ts
 var CANCELLED_MESSAGE = "Operation cancelled";
@@ -1689,8 +2206,8 @@ function formatPlan(changes) {
   for (const [label, group] of groups) {
     lines.push(`  ${label}:`);
     for (const change of group) {
-      const detail = change.detail ? `  ${chalk8.gray(`\u2014 ${change.detail}`)}` : "";
-      lines.push(`    ${chalk8.gray(`[${KIND_LABEL[change.kind]}]`)} ${change.path}${detail}`);
+      const detail = change.detail ? `  ${chalk9.gray(`\u2014 ${change.detail}`)}` : "";
+      lines.push(`    ${chalk9.gray(`[${KIND_LABEL[change.kind]}]`)} ${change.path}${detail}`);
     }
   }
   return lines;
@@ -1800,13 +2317,13 @@ function printInstallSummary(results) {
   if (successful.length > 0) {
     success(`Installed for ${successful.length} agent(s)`);
     for (const r of successful) {
-      console.log(chalk8.gray(`    \u2192 ${r.path}`));
+      console.log(chalk9.gray(`    \u2192 ${r.path}`));
     }
   }
   if (failed.length > 0) {
     error(`Failed for ${failed.length} agent(s)`);
     for (const r of failed) {
-      console.log(chalk8.red(`    \xD7 ${r.agent}: ${r.error}`));
+      console.log(chalk9.red(`    \xD7 ${r.agent}: ${r.error}`));
     }
   }
   return exitCode;
@@ -1820,7 +2337,7 @@ async function runAdd(name, options, cwd = process.cwd()) {
   const item = await resolveItem(name, options.type);
   if (item === CANCELLED) return 0;
   if (!item) return 1;
-  step(`Selected: ${brand(item.name)} ${chalk8.gray(`(${item.type})`)} ${chalk8.gray(`- ${item.description}`)}`);
+  step(`Selected: ${brand(item.name)} ${chalk9.gray(`(${item.type})`)} ${chalk9.gray(`- ${item.description}`)}`);
   const handler = getHandler(item.type);
   if (!handler) {
     error(`No handler found for type "${item.type}"`);
@@ -1835,10 +2352,24 @@ async function runAdd(name, options, cwd = process.cwd()) {
   step(`Scope: ${brand(scope)}`);
   const method = await chooseMethod(options, item, agents, scope, cwd);
   if (method === CANCELLED) return 0;
-  step(`Method: ${brand(method)}`);
+  if (method === "symlink" && handler.honoursMethod === false) {
+    step(`Method: ${brand("copy")} (${item.type} content cannot be symlinked)`);
+  } else {
+    step(`Method: ${brand(method)}`);
+  }
   if (options.dryRun) {
     info("Dry run - no files will be written");
-    printPlan("Would write:", await planInstall(handler, item, agents, scope, method, cwd));
+    const planned = await planInstall(handler, item, agents, scope, method, cwd);
+    printPlan("Would write:", planned);
+    const blocked = decideForce(options) ? [] : planned.filter((change) => change.kind === "modify");
+    if (blocked.length > 0) {
+      warn(
+        `${blocked.length} destination(s) already exist and would be refused without --force:`
+      );
+      for (const change of blocked) console.log(chalk9.gray(`    ${change.path}`));
+      outro("Dry run complete - the real run would fail without --force");
+      return 1;
+    }
     outro("Dry run complete");
     return 0;
   }
@@ -1857,7 +2388,7 @@ async function runAdd(name, options, cwd = process.cwd()) {
   if (exitCode === 0) outro("Installation complete");
   return exitCode;
 }
-var addCommand = new Command("add").description("Install a skill, agent, hook, or other configuration").argument("[name]", "Name of the item to install").option("-t, --type <type>", "Content type: skill, agent, hook, mcp, plugin, settings").option(
+var addCommand = new Command("add").description("Install a skill, agent, hook, or other configuration").argument("[name]", "Name of the item to install").option("-t, --type <type>", `Content type: ${TYPE_LIST}`).option(
   "-a, --agents <agents>",
   "Comma-separated coding agents or 'all' (claude,copilot,antigravity,codex,opencode; 'gemini' is a deprecated alias of antigravity). Every named agent must support the item; 'all' means all compatible agents. MCP servers: claude, codex, opencode (copilot's and antigravity's formats are unverified)"
 ).option("-s, --scope <scope>", "Installation scope: project, user, or local").option("-m, --method <method>", "Installation method: symlink or copy").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Overwrite existing files").option("-n, --dry-run", "Show exactly which files would be written, without writing or reporting anything").addHelpText("after", `
@@ -1874,17 +2405,18 @@ Telemetry: ${TELEMETRY_HELP_TEXT}.`).action(async (name, options) => {
 
 // src/commands/list.ts
 import { Command as Command2 } from "commander";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 var SEPARATOR_WIDTH = 40;
 var SLUG_COLUMN_WIDTH = 24;
 var TYPE_COLORS = {
-  skill: chalk9.magenta,
-  hook: chalk9.hex("#a855f7"),
-  agent: chalk9.blue,
-  plugin: chalk9.hex("#6366f1"),
-  command: chalk9.hex("#f59e0b"),
-  settings: chalk9.hex("#f97316"),
-  mcp: chalk9.hex("#2dd4bf")
+  skill: chalk10.magenta,
+  hook: chalk10.hex("#a855f7"),
+  agent: chalk10.blue,
+  plugin: chalk10.hex("#6366f1"),
+  command: chalk10.hex("#f59e0b"),
+  settings: chalk10.hex("#f97316"),
+  mcp: chalk10.hex("#2dd4bf"),
+  rule: chalk10.hex("#84cc16")
 };
 async function collectInstalledItems(params) {
   const types = params.types ?? getRegisteredTypes();
@@ -1913,7 +2445,7 @@ function resolveListAgents(agentsArg) {
 async function runList(options, cwd = process.cwd()) {
   const optionError = validateType(options.type) || validateScope(options.scope);
   if (optionError) {
-    console.log(chalk9.red(optionError));
+    console.log(chalk10.red(optionError));
     return 1;
   }
   const type = options.type;
@@ -1922,14 +2454,14 @@ async function runList(options, cwd = process.cwd()) {
   }
   const agents = resolveListAgents(options.agents);
   if (typeof agents === "string") {
-    console.log(chalk9.red(agents));
+    console.log(chalk10.red(agents));
     return 1;
   }
   const scope = options.scope ?? "project";
   await listInstalled({ types: type ? [type] : void 0, agents, scope, cwd });
   return 0;
 }
-var listCommand = new Command2("list").alias("ls").description("List available or installed items").option("-t, --type <type>", "Filter by type (skill, hook, agent, plugin, mcp, settings)").option("-i, --installed", "Show only installed items").option("-a, --agents <agents>", "Comma-separated coding agents or 'all' (installed check)", "all").option("--scope <scope>", "Scope for installed check (project, user, local)", "project").option("--label <label>", "Filter by label (see the registry's labels.json)").action(async (options) => {
+var listCommand = new Command2("list").alias("ls").description("List available or installed items").option("-t, --type <type>", `Filter by type: ${TYPE_LIST}`).option("-i, --installed", "Show only installed items").option("-a, --agents <agents>", "Comma-separated coding agents or 'all' (installed check)", "all").option("--scope <scope>", "Scope for installed check (project, user, local)", "project").option("--label <label>", "Filter by label (see the registry's labels.json)").action(async (options) => {
   try {
     const exitCode = await runList(options);
     if (exitCode !== 0) process.exit(exitCode);
@@ -1942,32 +2474,32 @@ async function listAvailable(type, label) {
   const items = label ? all.filter((item) => item.label === label) : all;
   if (items.length === 0 && label) {
     const known = [...new Set(all.map((item) => item.label).filter(Boolean))].sort();
-    console.log(chalk9.red(`No item carries the label "${label}".`));
-    if (known.length > 0) console.log(chalk9.gray(`Labels in use: ${known.join(", ")}`));
+    console.log(chalk10.red(`No item carries the label "${label}".`));
+    if (known.length > 0) console.log(chalk10.gray(`Labels in use: ${known.join(", ")}`));
     return 1;
   }
   if (items.length === 0) {
-    console.log(chalk9.yellow("No items found in registry"));
+    console.log(chalk10.yellow("No items found in registry"));
     return 0;
   }
   const grouped = groupByType(items);
   for (const [itemType, typeItems] of Object.entries(grouped)) {
-    const colorFn = TYPE_COLORS[itemType] ?? chalk9.white;
+    const colorFn = TYPE_COLORS[itemType] ?? chalk10.white;
     console.log(colorFn(`
 ${itemType.toUpperCase()}S`));
-    console.log(chalk9.gray("\u2500".repeat(SEPARATOR_WIDTH)));
+    console.log(chalk10.gray("\u2500".repeat(SEPARATOR_WIDTH)));
     for (const item of typeItems) {
       const compatIcons = [...new Set(item.compatibility.map((a) => CODING_AGENTS[a]?.shortName ?? a))].join(" ");
-      const featured = item.featured ? chalk9.yellow("\u2605 ") : "  ";
+      const featured = item.featured ? chalk10.yellow("\u2605 ") : "  ";
       console.log(
-        `${featured}${chalk9.white(item.slug.padEnd(SLUG_COLUMN_WIDTH))} ${chalk9.gray(compatIcons)}`
+        `${featured}${chalk10.white(item.slug.padEnd(SLUG_COLUMN_WIDTH))} ${chalk10.gray(compatIcons)}`
       );
-      console.log(`   ${chalk9.gray(item.description)}`);
+      console.log(`   ${chalk10.gray(item.description)}`);
     }
   }
   console.log("");
   console.log(
-    chalk9.gray(`Total: ${items.length} items. Use 'npx @danieldeusing/seedr add <name>' to install.`)
+    chalk10.gray(`Total: ${items.length} items. Use 'npx @danieldeusing/seedr add <name>' to install.`)
   );
   return 0;
 }
@@ -1981,23 +2513,23 @@ Installed items (${params.scope} scope):
   for (const group of groups) {
     if (group.type !== currentType) {
       currentType = group.type;
-      const colorFn = TYPE_COLORS[group.type] ?? chalk9.white;
+      const colorFn = TYPE_COLORS[group.type] ?? chalk10.white;
       console.log(colorFn(`${group.type.toUpperCase()}S`));
     }
-    console.log(chalk9.blue(`  ${CODING_AGENTS[group.agent].name}`));
+    console.log(chalk10.blue(`  ${CODING_AGENTS[group.agent].name}`));
     for (const slug of group.slugs) {
-      console.log(`    ${chalk9.white(slug)}`);
+      console.log(`    ${chalk10.white(slug)}`);
       total++;
     }
     console.log("");
   }
   if (!params.types || params.types.includes("settings")) {
-    console.log(chalk9.gray(`Note: ${SETTINGS_NOT_DISCOVERABLE}`));
+    console.log(chalk10.gray(`Note: ${SETTINGS_NOT_DISCOVERABLE}`));
   }
   if (total === 0) {
-    console.log(chalk9.yellow("No items installed"));
+    console.log(chalk10.yellow("No items installed"));
   } else {
-    console.log(chalk9.gray(`Total: ${total} installed`));
+    console.log(chalk10.gray(`Total: ${total} installed`));
   }
 }
 function groupByType(items) {
@@ -2015,8 +2547,8 @@ function groupByType(items) {
 
 // src/commands/remove.ts
 import { Command as Command3 } from "commander";
-import chalk10 from "chalk";
-import ora7 from "ora";
+import chalk11 from "chalk";
+import ora8 from "ora";
 async function findInstalledAgents(slug, type, scope, cwd) {
   const handler = getHandler(type);
   if (!handler) return [];
@@ -2034,13 +2566,19 @@ async function removeFromAgents(slug, type, agents, scope, cwd) {
   if (!handler) return 0;
   let successCount = 0;
   for (const agent of agents) {
-    const spinner = ora7(`Removing from ${CODING_AGENTS[agent].name}...`).start();
+    if (!isTypeSupported(type, agent)) {
+      ora8().start().info(
+        chalk11.gray(`Skipped ${CODING_AGENTS[agent].name}: ${describeIncompatibility(type, agent)}`)
+      );
+      continue;
+    }
+    const spinner = ora8(`Removing from ${CODING_AGENTS[agent].name}...`).start();
     const removed = await handler.uninstall(slug, agent, scope, cwd);
     if (removed) {
       spinner.succeed(brand(`Removed from ${CODING_AGENTS[agent].name}`));
       successCount++;
     } else {
-      spinner.info(chalk10.gray(`Not found in ${CODING_AGENTS[agent].name}`));
+      spinner.info(chalk11.gray(`Not found in ${CODING_AGENTS[agent].name}`));
     }
   }
   return successCount;
@@ -2065,14 +2603,14 @@ function validateRemoveRequest(name, options) {
 async function runRemove(name, options, cwd = process.cwd()) {
   const requestError = validateRemoveRequest(name, options);
   if (requestError) {
-    console.log(chalk10.red(requestError));
+    console.log(chalk11.red(requestError));
     return 1;
   }
   const scope = options.scope ?? "project";
   const type = options.type;
   const handler = getHandler(type);
   if (!handler) {
-    console.log(chalk10.red(`No handler found for type "${type}"`));
+    console.log(chalk11.red(`No handler found for type "${type}"`));
     return 1;
   }
   let agents;
@@ -2085,11 +2623,11 @@ async function runRemove(name, options, cwd = process.cwd()) {
   }
   if (agents.length === 0) {
     if (type === "settings") {
-      console.log(chalk10.yellow(`Cannot detect where "${name}" is installed: ${SETTINGS_NOT_DISCOVERABLE}`));
-      console.log(chalk10.gray("Name the agents explicitly, e.g. --agents claude"));
+      console.log(chalk11.yellow(`Cannot detect where "${name}" is installed: ${SETTINGS_NOT_DISCOVERABLE}`));
+      console.log(chalk11.gray("Name the agents explicitly, e.g. --agents claude"));
       return 1;
     }
-    console.log(chalk10.yellow(`${type} "${name}" is not installed in ${scope} scope`));
+    console.log(chalk11.yellow(`${type} "${name}" is not installed in ${scope} scope`));
     return 0;
   }
   if (!options.yes) {
@@ -2102,7 +2640,7 @@ Will remove ${type} "${name}" from:`));
     const answer = await confirm("Proceed with removal?");
     const confirmed = !p.isCancel(answer) && answer;
     if (!confirmed) {
-      console.log(chalk10.yellow("Removal cancelled"));
+      console.log(chalk11.yellow("Removal cancelled"));
       return 0;
     }
   }
@@ -2112,10 +2650,10 @@ Will remove ${type} "${name}" from:`));
     console.log(brand(`Successfully removed from ${successCount} agent(s)`));
     return 0;
   }
-  console.log(chalk10.yellow("Nothing to remove"));
+  console.log(chalk11.yellow("Nothing to remove"));
   return 0;
 }
-var removeCommand = new Command3("remove").alias("rm").description("Remove an installed item (skill, plugin, agent, hook, mcp)").argument("<name>", "Name/slug of the item to remove").option("-t, --type <type>", "Content type: skill, agent, hook, mcp, plugin, settings").option(
+var removeCommand = new Command3("remove").alias("rm").description("Remove an installed item (skill, plugin, agent, hook, mcp)").argument("<name>", "Name/slug of the item to remove").option("-t, --type <type>", `Content type: ${TYPE_LIST}`).option(
   "-a, --agents <agents>",
   "Comma-separated coding agents or 'all'"
 ).option(
@@ -2133,9 +2671,9 @@ var removeCommand = new Command3("remove").alias("rm").description("Remove an in
 
 // src/commands/init.ts
 import { Command as Command4 } from "commander";
-import chalk11 from "chalk";
-import ora8 from "ora";
-import { join as join5 } from "path";
+import chalk12 from "chalk";
+import ora9 from "ora";
+import { join as join7 } from "path";
 function readmeFor(agent) {
   return `# ${CODING_AGENTS[agent].name} Configuration
 
@@ -2153,7 +2691,7 @@ async function initializeAgent(agent, cwd) {
   const path = getAgentPath(agent, "project", cwd);
   if (await exists(path)) return false;
   await ensureDir(path);
-  await writeTextFile(join5(path, "README.md"), readmeFor(agent));
+  await writeTextFile(join7(path, "README.md"), readmeFor(agent));
   return true;
 }
 async function runInit(options, cwd = process.cwd()) {
@@ -2164,13 +2702,13 @@ async function runInit(options, cwd = process.cwd()) {
   } else {
     const parsed = parseAgentsArgStrict(agentsArg);
     if (parsed.unknown.length > 0) {
-      console.error(chalk11.red(`Unknown agent(s): ${parsed.unknown.join(", ")}. Valid agents: ${ALL_AGENTS.join(", ")} or "all"`));
+      console.error(chalk12.red(`Unknown agent(s): ${parsed.unknown.join(", ")}. Valid agents: ${ALL_AGENTS.join(", ")} or "all"`));
       return 1;
     }
     agents = parsed.agents;
   }
   if (agents.length === 0) {
-    console.error(chalk11.red("No valid agents specified"));
+    console.error(chalk12.red("No valid agents specified"));
     return 1;
   }
   console.log(brand("\nWill initialize configuration for:"));
@@ -2182,16 +2720,16 @@ async function runInit(options, cwd = process.cwd()) {
     const answer = await confirm("Proceed?");
     const confirmed = !p.isCancel(answer) && answer;
     if (!confirmed) {
-      console.log(chalk11.yellow("Cancelled"));
+      console.log(chalk12.yellow("Cancelled"));
       return 0;
     }
   }
   for (const agent of agents) {
-    const spinner = ora8(`Initializing ${CODING_AGENTS[agent].name}...`).start();
+    const spinner = ora9(`Initializing ${CODING_AGENTS[agent].name}...`).start();
     if (await initializeAgent(agent, cwd)) {
       spinner.succeed(brand(`Initialized ${CODING_AGENTS[agent].name}`));
     } else {
-      spinner.info(chalk11.gray(`${CODING_AGENTS[agent].name} already initialized`));
+      spinner.info(chalk12.gray(`${CODING_AGENTS[agent].name} already initialized`));
     }
   }
   console.log("");
@@ -2214,7 +2752,7 @@ var initCommand = new Command4("init").description("Initialize coding agent conf
 // package.json
 var package_default = {
   name: "@danieldeusing/seedr",
-  version: "0.1.97",
+  version: "0.1.99",
   description: "Seed your projects with AI configurations",
   type: "module",
   bin: {