agentinit 1.14.0 → 1.15.1

package/dist/cli.js

@@ -16717,15 +16717,207 @@ var init_agentManager = __esm(() => {
   init_ZedAgent();
 });
 
+// dist/core/userConfig.js
+import {existsSync, readFileSync} from "fs";
+import {promises as fs20} from "fs";
+import {homedir as homedir3} from "os";
+import {join as join3} from "path";
+function getUserConfigPath() {
+  return join3(homedir3(), ".agentinit", "config.json");
+}
+function createDefaultUserConfig() {
+  return {
+    customMarketplaces: [],
+    verifiedGithubRepos: []
+  };
+}
+function normalizeMarketplaceIdentifier(identifier) {
+  const normalized = identifier.trim().toLowerCase();
+  if (!MARKETPLACE_IDENTIFIER_PATTERN.test(normalized)) {
+    throw new Error('Invalid marketplace identifier. Use lowercase letters, numbers, ".", "_" or "-".');
+  }
+  return normalized;
+}
+function normalizeMarketplaceName(name, identifier) {
+  const normalized = name?.trim();
+  return normalized ? normalized : identifier;
+}
+function normalizeMarketplaceRepoUrl(repoUrl) {
+  const normalized = repoUrl.trim().replace(/\/+$/, "");
+  if (!normalized || !GIT_REPO_URL_PATTERN.test(normalized)) {
+    throw new Error("Invalid marketplace repo URL. Use https://..., ssh://..., or git@...");
+  }
+  return normalized;
+}
+function normalizeGitHubRepoRef(repo) {
+  const normalized = repo.trim();
+  const match = normalized.match(GITHUB_REPO_PATTERN);
+  if (!match) {
+    throw new Error("Invalid GitHub repo. Use exact owner/repo.");
+  }
+  return `${match[1].toLowerCase()}/${match[2].toLowerCase()}`;
+}
+function sanitizeUserConfig(raw) {
+  const defaults = createDefaultUserConfig();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return defaults;
+  }
+  const parsed = raw;
+  const seenMarketplaces = new Set;
+  const customMarketplaces = [];
+  if (Array.isArray(parsed.customMarketplaces)) {
+    for (const entry of parsed.customMarketplaces) {
+      const sanitized = sanitizeCustomMarketplaceConfig(entry);
+      if (!sanitized || seenMarketplaces.has(sanitized.identifier)) {
+        continue;
+      }
+      seenMarketplaces.add(sanitized.identifier);
+      customMarketplaces.push(sanitized);
+    }
+  }
+  const seenRepos = new Set;
+  const verifiedGithubRepos = [];
+  if (Array.isArray(parsed.verifiedGithubRepos)) {
+    for (const entry of parsed.verifiedGithubRepos) {
+      if (typeof entry !== "string") {
+        continue;
+      }
+      try {
+        const normalized = normalizeGitHubRepoRef(entry);
+        if (seenRepos.has(normalized)) {
+          continue;
+        }
+        seenRepos.add(normalized);
+        verifiedGithubRepos.push(normalized);
+      } catch {
+        continue;
+      }
+    }
+  }
+  let defaultMarketplace;
+  if (typeof parsed.defaultMarketplace === "string") {
+    try {
+      defaultMarketplace = normalizeMarketplaceIdentifier(parsed.defaultMarketplace);
+    } catch {
+      defaultMarketplace = undefined;
+    }
+  }
+  return {
+    ...defaultMarketplace ? { defaultMarketplace } : {},
+    customMarketplaces,
+    verifiedGithubRepos
+  };
+}
+function readUserConfigSync() {
+  const configPath = getUserConfigPath();
+  if (!existsSync(configPath)) {
+    return createDefaultUserConfig();
+  }
+  try {
+    const content = readFileSync(configPath, "utf8");
+    return sanitizeUserConfig(JSON.parse(content));
+  } catch {
+    return createDefaultUserConfig();
+  }
+}
+async function readUserConfig() {
+  const configPath = getUserConfigPath();
+  try {
+    const content = await fs20.readFile(configPath, "utf8");
+    return sanitizeUserConfig(JSON.parse(content));
+  } catch {
+    return createDefaultUserConfig();
+  }
+}
+async function writeUserConfig(config) {
+  const sanitized = sanitizeUserConfig(config);
+  await writeFile(getUserConfigPath(), `${JSON.stringify(sanitized, null, 2)}\n`);
+}
+function getBuiltInVerifiedGithubRepos() {
+  return [...BUILTIN_VERIFIED_GITHUB_REPOS];
+}
+function getEffectiveVerifiedGithubReposSync() {
+  const repos = new Set(BUILTIN_VERIFIED_GITHUB_REPOS);
+  for (const repo of readUserConfigSync().verifiedGithubRepos) {
+    repos.add(repo);
+  }
+  return [...repos];
+}
+function isVerifiedGitHubRepoSync(owner, repo) {
+  const normalized = normalizeGitHubRepoRef(`${owner}/${repo}`);
+  return getEffectiveVerifiedGithubReposSync().includes(normalized);
+}
+var sanitizeCustomMarketplaceConfig, MARKETPLACE_IDENTIFIER_PATTERN, GITHUB_REPO_PATTERN, GIT_REPO_URL_PATTERN, BUILTIN_VERIFIED_GITHUB_REPOS;
+var init_userConfig = __esm(() => {
+  init_fs();
+  sanitizeCustomMarketplaceConfig = function(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      return null;
+    }
+    const candidate = entry;
+    try {
+      const identifier = normalizeMarketplaceIdentifier(String(candidate.identifier || ""));
+      return {
+        identifier,
+        name: normalizeMarketplaceName(typeof candidate.name === "string" ? candidate.name : undefined, identifier),
+        repoUrl: normalizeMarketplaceRepoUrl(String(candidate.repoUrl || ""))
+      };
+    } catch {
+      return null;
+    }
+  };
+  MARKETPLACE_IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+  GITHUB_REPO_PATTERN = /^([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)$/;
+  GIT_REPO_URL_PATTERN = /^(https?:\/\/|ssh:\/\/|git@).+/;
+  BUILTIN_VERIFIED_GITHUB_REPOS = ["openai/codex-plugin-cc"];
+});
+
 // dist/core/marketplaceRegistry.js
+function getMarketplaceCategoryForDir(dir) {
+  if (dir === "plugins") {
+    return "official";
+  }
+  if (dir === "external_plugins") {
+    return "community";
+  }
+  if (dir.startsWith("skills/.")) {
+    return dir.slice("skills/.".length);
+  }
+  return dir;
+}
 function getMarketplace(id) {
-  return MARKETPLACES.find((marketplace) => marketplace.id === id);
+  return getAllMarketplaces().find((marketplace) => marketplace.id === id);
 }
 function getMarketplaceIds() {
-  return MARKETPLACES.map((marketplace) => marketplace.id);
+  return getAllMarketplaces().map((marketplace) => marketplace.id);
+}
+function getMarketplaceCategories(id) {
+  const marketplaces = id ? [getMarketplace(id)].filter((marketplace) => !!marketplace) : getAllMarketplaces();
+  return [...new Set(marketplaces.flatMap((marketplace) => marketplace.pluginDirs.map(getMarketplaceCategoryForDir)))];
+}
+function getConfiguredDefaultMarketplaceId() {
+  const defaultMarketplace = readUserConfigSync().defaultMarketplace;
+  if (!defaultMarketplace) {
+    return;
+  }
+  return getMarketplace(defaultMarketplace)?.id;
 }
-var MARKETPLACES;
+var getCustomMarketplaces, getAllMarketplaces, MARKETPLACES, CUSTOM_MARKETPLACE_PLUGIN_DIRS, CUSTOM_MARKETPLACE_CACHE_TTL_MS;
 var init_marketplaceRegistry = __esm(() => {
+  init_userConfig();
+  getCustomMarketplaces = function() {
+    const builtInIds = new Set(MARKETPLACES.map((marketplace) => marketplace.id));
+    return readUserConfigSync().customMarketplaces.filter((marketplace) => !builtInIds.has(marketplace.identifier)).map((marketplace) => ({
+      id: marketplace.identifier,
+      name: marketplace.name,
+      repoUrl: marketplace.repoUrl,
+      pluginDirs: [...CUSTOM_MARKETPLACE_PLUGIN_DIRS],
+      cacheTtlMs: CUSTOM_MARKETPLACE_CACHE_TTL_MS
+    }));
+  };
+  getAllMarketplaces = function() {
+    return [...MARKETPLACES, ...getCustomMarketplaces()];
+  };
   MARKETPLACES = [
     {
       id: "agentinit",
@@ -16749,6 +16941,8 @@ var init_marketplaceRegistry = __esm(() => {
       cacheTtlMs: 3600000
     }
   ];
+  CUSTOM_MARKETPLACE_PLUGIN_DIRS = ["skills", "mcps", "rules"];
+  CUSTOM_MARKETPLACE_CACHE_TTL_MS = 3600000;
 });
 
 // dist/core/mcpFilter.js
@@ -16860,9 +17054,9 @@ __export(exports_pluginManager, {
     }
   }
 });
-import {resolve as resolve7, join as join3, basename as basename2, relative as relative2, dirname as dirname2} from "path";
-import {promises as fs20} from "fs";
-import {homedir as homedir3} from "os";
+import {resolve as resolve7, join as join4, basename as basename2, relative as relative2, dirname as dirname2} from "path";
+import {promises as fs22} from "fs";
+import {homedir as homedir4} from "os";
 
 class MarketplacePluginNotFoundError extends Error {
   pluginName;
@@ -16896,7 +17090,7 @@ class PluginManager {
   }
   async cleanupLoadedPluginContext(context) {
     if (context?.tempDir) {
-      await fs20.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
+      await fs22.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -16968,13 +17162,13 @@ class PluginManager {
     return `https://github.com/${source.owner}/${source.repo}`;
   }
   getGitHubFallbackTrust(source) {
-    if (source.owner === "openai" && source.repo === "codex-plugin-cc") {
+    if (source.owner && source.repo && isVerifiedGitHubRepoSync(source.owner, source.repo)) {
       return "verified";
     }
     return "unverified";
   }
   async resolvePreparedPluginDir(pluginDir, source) {
-    const claudeMarketplaceManifestPath = join3(pluginDir, ".claude-plugin", "marketplace.json");
+    const claudeMarketplaceManifestPath = join4(pluginDir, ".claude-plugin", "marketplace.json");
     if (!await fileExists(claudeMarketplaceManifestPath)) {
       return { pluginDir, warnings: [] };
     }
@@ -17115,13 +17309,13 @@ class PluginManager {
   }
   async getClaudeNativeFeatureKinds(pluginDir, manifest) {
     const featureChecks = await Promise.all([
-      (async () => !!manifest.commands || await isDirectory(join3(pluginDir, "commands")))(),
-      (async () => !!manifest.hooks || await isDirectory(join3(pluginDir, "hooks")))(),
-      (async () => !!manifest.agents || await isDirectory(join3(pluginDir, "agents")))(),
-      isDirectory(join3(pluginDir, "prompts")),
-      isDirectory(join3(pluginDir, "schemas")),
-      isDirectory(join3(pluginDir, "scripts")),
-      isDirectory(join3(pluginDir, "templates"))
+      (async () => !!manifest.commands || await isDirectory(join4(pluginDir, "commands")))(),
+      (async () => !!manifest.hooks || await isDirectory(join4(pluginDir, "hooks")))(),
+      (async () => !!manifest.agents || await isDirectory(join4(pluginDir, "agents")))(),
+      isDirectory(join4(pluginDir, "prompts")),
+      isDirectory(join4(pluginDir, "schemas")),
+      isDirectory(join4(pluginDir, "scripts")),
+      isDirectory(join4(pluginDir, "templates"))
     ]);
     return [
       ...featureChecks[0] ? ["commands"] : [],
@@ -17137,7 +17331,7 @@ class PluginManager {
     if (plugin.format !== "claude") {
       return null;
     }
-    const manifestContent = await readFileIfExists(join3(pluginDir, ".claude-plugin", "plugin.json"));
+    const manifestContent = await readFileIfExists(join4(pluginDir, ".claude-plugin", "plugin.json"));
     if (!manifestContent) {
       return null;
     }
@@ -17157,7 +17351,7 @@ class PluginManager {
     return {
       namespace,
       pluginKey: `${plugin.name}@${namespace}`,
-      installPath: join3(homedir3(), ".claude", "plugins", "cache", namespace, plugin.name, versionDir),
+      installPath: join4(homedir4(), ".claude", "plugins", "cache", namespace, plugin.name, versionDir),
       features
     };
   }
@@ -17230,10 +17424,10 @@ class PluginManager {
       warnings.push(`Skipped native Claude plugin install because Claude already has "${plugin.name}" installed as ${conflictingKey}.`);
       return { installed, skipped, warnings };
     }
-    await fs20.rm(nativeTarget.installPath, { recursive: true, force: true }).catch(() => {
+    await fs22.rm(nativeTarget.installPath, { recursive: true, force: true }).catch(() => {
     });
-    await fs20.mkdir(dirname2(nativeTarget.installPath), { recursive: true });
-    await fs20.cp(pluginDir, nativeTarget.installPath, { recursive: true, dereference: true });
+    await fs22.mkdir(dirname2(nativeTarget.installPath), { recursive: true });
+    await fs22.cp(pluginDir, nativeTarget.installPath, { recursive: true, dereference: true });
     const now = new Date().toISOString();
     claudeInstalled.plugins[nativeTarget.pluginKey] = [{
       scope: "user",
@@ -17281,7 +17475,7 @@ class PluginManager {
       claudeSettings.enabledPlugins = remainingEnabledPlugins;
       await this.saveClaudeSettings(claudeSettings);
     }
-    await fs20.rm(component.installPath, { recursive: true, force: true }).catch(() => {
+    await fs22.rm(component.installPath, { recursive: true, force: true }).catch(() => {
     });
     return true;
   }
@@ -17332,7 +17526,7 @@ class PluginManager {
         repo
       };
     }
-    const defaultMarketplace = this.getMarketplaceIds()[0];
+    const defaultMarketplace = getConfiguredDefaultMarketplaceId() || this.getMarketplaceIds()[0];
     if (defaultMarketplace) {
       return {
         type: "marketplace",
@@ -17351,43 +17545,81 @@ class PluginManager {
   async ensureMarketplaceCache(registryId) {
     const registry = this.getMarketplace(registryId);
     if (!registry) {
-      throw new Error(`Unknown marketplace: ${registryId}. Available: ${MARKETPLACES.map((m) => m.id).join(", ")}`);
+      throw new Error(`Unknown marketplace: ${registryId}. Available: ${this.getMarketplaceIds().join(", ")}`);
     }
     const cacheDir = getMarketplaceCacheDir(registryId);
-    const cacheMetaPath = join3(cacheDir, ".agentinit-cache-meta.json");
-    if (await fileExists(cacheMetaPath)) {
-      try {
-        const meta = JSON.parse(await fs20.readFile(cacheMetaPath, "utf8"));
-        const age = Date.now() - (meta.fetchedAt || 0);
-        if (age < registry.cacheTtlMs) {
-          return cacheDir;
-        }
-      } catch {
-      }
-    }
-    if (await fileExists(join3(cacheDir, ".git"))) {
-      const { execFile } = await import("child_process");
-      const { promisify } = await import("util");
-      const exec = promisify(execFile);
-      try {
-        await exec("git", ["pull", "--ff-only"], { cwd: cacheDir, timeout: 30000 });
-      } catch {
-        await fs20.rm(cacheDir, { recursive: true, force: true });
+    const cacheMetaPath = join4(cacheDir, ".agentinit-cache-meta.json");
+    const cacheMeta = await this.readMarketplaceCacheMeta(cacheMetaPath);
+    if (cacheMeta?.repoUrl === registry.repoUrl) {
+      const age = Date.now() - cacheMeta.fetchedAt;
+      if (age < registry.cacheTtlMs) {
+        return cacheDir;
+      }
+    }
+    if (await fileExists(join4(cacheDir, ".git"))) {
+      const originUrl = await this.getMarketplaceCacheOriginUrl(cacheDir);
+      if (originUrl !== registry.repoUrl) {
+        await fs22.rm(cacheDir, { recursive: true, force: true });
         await this.cloneMarketplace(registry.repoUrl, cacheDir);
+      } else {
+        const { execFile } = await import("child_process");
+        const { promisify } = await import("util");
+        const exec = promisify(execFile);
+        try {
+          await exec("git", ["pull", "--ff-only"], { cwd: cacheDir, timeout: 30000 });
+        } catch {
+          await fs22.rm(cacheDir, { recursive: true, force: true });
+          await this.cloneMarketplace(registry.repoUrl, cacheDir);
+        }
       }
     } else {
       await this.cloneMarketplace(registry.repoUrl, cacheDir);
     }
-    await fs20.mkdir(cacheDir, { recursive: true });
-    await fs20.writeFile(cacheMetaPath, JSON.stringify({ fetchedAt: Date.now() }));
+    await fs22.mkdir(cacheDir, { recursive: true });
+    await fs22.writeFile(cacheMetaPath, JSON.stringify({
+      fetchedAt: Date.now(),
+      repoUrl: registry.repoUrl
+    }));
     return cacheDir;
   }
+  async readMarketplaceCacheMeta(cacheMetaPath) {
+    if (!await fileExists(cacheMetaPath)) {
+      return null;
+    }
+    try {
+      const meta = JSON.parse(await fs22.readFile(cacheMetaPath, "utf8"));
+      if (typeof meta.fetchedAt !== "number") {
+        return null;
+      }
+      return {
+        fetchedAt: meta.fetchedAt,
+        ...typeof meta.repoUrl === "string" ? { repoUrl: meta.repoUrl } : {}
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getMarketplaceCacheOriginUrl(cacheDir) {
+    const { execFile } = await import("child_process");
+    const { promisify } = await import("util");
+    const exec = promisify(execFile);
+    try {
+      const { stdout } = await exec("git", ["config", "--get", "remote.origin.url"], {
+        cwd: cacheDir,
+        timeout: 30000
+      });
+      const originUrl = stdout.trim();
+      return originUrl || null;
+    } catch {
+      return null;
+    }
+  }
   async cloneMarketplace(repoUrl, dest) {
-    await fs20.mkdir(dest, { recursive: true });
+    await fs22.mkdir(dest, { recursive: true });
     const { execFile } = await import("child_process");
     const { promisify } = await import("util");
     const exec = promisify(execFile);
-    await fs20.rm(dest, { recursive: true, force: true }).catch(() => {
+    await fs22.rm(dest, { recursive: true, force: true }).catch(() => {
     });
     await exec("git", ["clone", "--depth", "1", repoUrl, dest], { timeout: 60000 });
   }
@@ -17397,7 +17629,7 @@ class PluginManager {
       throw new Error(`Unknown marketplace: ${registryId}`);
     const cacheDir = await this.ensureMarketplaceCache(registryId);
     for (const dir of registry.pluginDirs) {
-      const pluginPath = join3(cacheDir, dir, name);
+      const pluginPath = join4(cacheDir, dir, name);
       if (await isDirectory(pluginPath)) {
         return pluginPath;
       }
@@ -17413,36 +17645,36 @@ class PluginManager {
     const cacheDir = await this.ensureMarketplaceCache(registryId);
     const results = [];
     for (const dir of registry.pluginDirs) {
-      const fullDir = join3(cacheDir, dir);
+      const fullDir = join4(cacheDir, dir);
       if (!await isDirectory(fullDir))
         continue;
-      const cat = dir === "plugins" ? "official" : dir === "external_plugins" ? "community" : dir.startsWith("skills/.") ? dir.slice("skills/.".length) : dir;
+      const cat = getMarketplaceCategoryForDir(dir);
       if (category && cat !== category)
         continue;
       const entries = await listFiles(fullDir);
       for (const entry of entries) {
         if (entry.startsWith("."))
           continue;
-        const entryPath = join3(fullDir, entry);
+        const entryPath = join4(fullDir, entry);
         if (!await isDirectory(entryPath))
           continue;
-        const manifestPath = join3(entryPath, ".claude-plugin", "plugin.json");
+        const manifestPath = join4(entryPath, ".claude-plugin", "plugin.json");
         let name = entry;
         let description = "";
         let version = "0.0.0";
         if (await fileExists(manifestPath)) {
           try {
-            const manifest = JSON.parse(await fs20.readFile(manifestPath, "utf8"));
+            const manifest = JSON.parse(await fs22.readFile(manifestPath, "utf8"));
             name = manifest.name || entry;
             description = manifest.description || "";
             version = manifest.version || "0.0.0";
           } catch {
           }
         } else {
-          const skillMdPath = join3(entryPath, "SKILL.md");
+          const skillMdPath = join4(entryPath, "SKILL.md");
           if (await fileExists(skillMdPath)) {
             try {
-              const parsed = import_gray_matter.default(await fs20.readFile(skillMdPath, "utf8"));
+              const parsed = import_gray_matter.default(await fs22.readFile(skillMdPath, "utf8"));
               if (parsed.data.name)
                 name = parsed.data.name;
               if (parsed.data.description)
@@ -17450,10 +17682,10 @@ class PluginManager {
             } catch {
             }
           } else {
-            const mcpPath = join3(entryPath, ".mcp.json");
+            const mcpPath = join4(entryPath, ".mcp.json");
             if (await fileExists(mcpPath)) {
               try {
-                const mcpConfig = JSON.parse(await fs20.readFile(mcpPath, "utf8"));
+                const mcpConfig = JSON.parse(await fs22.readFile(mcpPath, "utf8"));
                 const serverNames = Object.keys(mcpConfig.mcpServers || mcpConfig);
                 if (serverNames.length > 0) {
                   description = `MCP server(s): ${serverNames.join(", ")}`;
@@ -17475,10 +17707,10 @@ class PluginManager {
     return results.sort((a, b) => a.name.localeCompare(b.name));
   }
   async detectFormat(pluginDir) {
-    if (await fileExists(join3(pluginDir, ".claude-plugin", "plugin.json"))) {
+    if (await fileExists(join4(pluginDir, ".claude-plugin", "plugin.json"))) {
       return "claude";
     }
-    if (await fileExists(join3(pluginDir, ".cursor-plugin", "plugin.json"))) {
+    if (await fileExists(join4(pluginDir, ".cursor-plugin", "plugin.json"))) {
       return "cursor";
     }
     return "generic";
@@ -17495,7 +17727,7 @@ class PluginManager {
     }
   }
   async parseClaudePlugin(pluginDir, source) {
-    const manifestPath = join3(pluginDir, ".claude-plugin", "plugin.json");
+    const manifestPath = join4(pluginDir, ".claude-plugin", "plugin.json");
     const manifestContent = await readFileIfExists(manifestPath);
     if (!manifestContent) {
       throw new Error(`Missing .claude-plugin/plugin.json in ${pluginDir}`);
@@ -17506,10 +17738,10 @@ class PluginManager {
     const convertedSkills = await this.convertCommandsToSkills(pluginDir, manifest);
     skills.push(...convertedSkills);
     const mcpServers = await this.parseMcpJson(pluginDir);
-    if (await isDirectory(join3(pluginDir, "hooks")) || manifest.hooks) {
+    if (await isDirectory(join4(pluginDir, "hooks")) || manifest.hooks) {
       warnings.push("Hooks (hooks/) are Claude Code-specific");
     }
-    if (await isDirectory(join3(pluginDir, "agents")) || manifest.agents) {
+    if (await isDirectory(join4(pluginDir, "agents")) || manifest.agents) {
       warnings.push("Agent definitions (agents/) are Claude Code-specific");
     }
     return {
@@ -17524,7 +17756,7 @@ class PluginManager {
     };
   }
   async parseCursorPlugin(pluginDir, source) {
-    const manifestPath = join3(pluginDir, ".cursor-plugin", "plugin.json");
+    const manifestPath = join4(pluginDir, ".cursor-plugin", "plugin.json");
     const manifestContent = await readFileIfExists(manifestPath);
     if (!manifestContent) {
       throw new Error(`Missing .cursor-plugin/plugin.json in ${pluginDir}`);
@@ -17563,7 +17795,7 @@ class PluginManager {
     };
   }
   async parseMcpJson(pluginDir) {
-    const mcpPath = join3(pluginDir, ".mcp.json");
+    const mcpPath = join4(pluginDir, ".mcp.json");
     const content = await readFileIfExists(mcpPath);
     if (!content)
       return [];
@@ -17610,7 +17842,7 @@ class PluginManager {
         commandsDirs.push(resolve7(pluginDir, cmd));
       }
     } else {
-      commandsDirs.push(join3(pluginDir, "commands"));
+      commandsDirs.push(join4(pluginDir, "commands"));
     }
     for (const commandsDir of commandsDirs) {
       if (!await isDirectory(commandsDir))
@@ -17619,7 +17851,7 @@ class PluginManager {
       for (const entry of entries) {
         if (!entry.endsWith(".md"))
           continue;
-        const cmdPath = join3(commandsDir, entry);
+        const cmdPath = join4(commandsDir, entry);
         const skill = await this.convertSingleCommandToSkill(cmdPath, manifest.name);
         if (skill)
           skills.push(skill);
@@ -17908,7 +18140,7 @@ ${body.trim()}
       }
       if (!removedSkillPaths.has(skill.path)) {
         try {
-          await fs20.rm(skill.path, { recursive: true, force: true });
+          await fs22.rm(skill.path, { recursive: true, force: true });
           removedSkillPaths.add(skill.path);
         } catch {
           details.push(`Could not remove skill path: ${skill.path}`);
@@ -17917,7 +18149,7 @@ ${body.trim()}
       }
       if (skill.canonicalPath && skill.canonicalPath !== skill.path && !removedCanonicalPaths.has(skill.canonicalPath) && !sharedCanonicalPath) {
         try {
-          await fs20.rm(skill.canonicalPath, { recursive: true, force: true });
+          await fs22.rm(skill.canonicalPath, { recursive: true, force: true });
           removedCanonicalPaths.add(skill.canonicalPath);
         } catch {
           details.push(`Could not remove canonical skill path: ${skill.canonicalPath}`);
@@ -18021,27 +18253,28 @@ var init_pluginManager = __esm(() => {
   init_mcpFilter();
   init_marketplaceRegistry();
   init_skillsManager();
+  init_userConfig();
   getMarketplaceCacheDir = function(registryId) {
-    return join3(homedir3(), ".agentinit", "marketplace-cache", registryId);
+    return join4(homedir4(), ".agentinit", "marketplace-cache", registryId);
   };
   getRegistryPath = function(projectPath, global3) {
     if (global3) {
-      return join3(homedir3(), ".agentinit", "plugins.json");
+      return join4(homedir4(), ".agentinit", "plugins.json");
     }
-    return join3(projectPath, ".agentinit", "plugins.json");
+    return join4(projectPath, ".agentinit", "plugins.json");
   };
   getClaudeInstalledPluginsPath = function() {
-    return join3(homedir3(), ".claude", "plugins", "installed_plugins.json");
+    return join4(homedir4(), ".claude", "plugins", "installed_plugins.json");
   };
   getClaudeSettingsPath = function() {
-    return join3(homedir3(), ".claude", "settings.json");
+    return join4(homedir4(), ".claude", "settings.json");
   };
 });
 
 // dist/core/skillsManager.js
-import {resolve as resolve8, join as join4, relative as relative3} from "path";
-import {promises as fs22} from "fs";
-import {homedir as homedir4, tmpdir} from "os";
+import {resolve as resolve8, join as join5, relative as relative3} from "path";
+import {promises as fs24} from "fs";
+import {homedir as homedir5, tmpdir} from "os";
 import {execFile} from "child_process";
 import {promisify} from "util";
 
@@ -18108,6 +18341,17 @@ class SkillsManager {
   }
   resolveSourceRequest(source, options2) {
     if (this.isImplicitCatalogSkillSource(source, options2)) {
+      const configuredDefaultMarketplace = getConfiguredDefaultMarketplaceId();
+      if (configuredDefaultMarketplace) {
+        return {
+          source: {
+            type: "marketplace",
+            marketplace: configuredDefaultMarketplace,
+            pluginName: source.trim()
+          },
+          implicitSkills: []
+        };
+      }
       return {
         source: {
           type: "github",
@@ -18144,7 +18388,7 @@ class SkillsManager {
       const fullDir = resolve8(repoPath, searchDir);
       if (!await fileExists(fullDir))
         continue;
-      const directSkillMd = join4(fullDir, "SKILL.md");
+      const directSkillMd = join5(fullDir, "SKILL.md");
       if (await fileExists(directSkillMd)) {
         const parsed = await this.parseSkillMd(directSkillMd);
         if (parsed && !seen.has(parsed.name)) {
@@ -18152,7 +18396,7 @@ class SkillsManager {
           skills.push({ ...parsed, path: resolve8(fullDir) });
         }
       }
-      const directSkillMdLower = join4(fullDir, "skill.md");
+      const directSkillMdLower = join5(fullDir, "skill.md");
       if (await fileExists(directSkillMdLower)) {
         const parsed = await this.parseSkillMd(directSkillMdLower);
         if (parsed && !seen.has(parsed.name)) {
@@ -18164,11 +18408,11 @@ class SkillsManager {
         continue;
       const entries = await listFiles(fullDir);
       for (const entry of entries) {
-        const entryPath = join4(fullDir, entry);
+        const entryPath = join5(fullDir, entry);
         if (!await isDirectory(entryPath))
           continue;
-        const skillMdPath = join4(entryPath, "SKILL.md");
-        const skillMdPathLower = join4(entryPath, "skill.md");
+        const skillMdPath = join5(entryPath, "SKILL.md");
+        const skillMdPathLower = join5(entryPath, "skill.md");
         const skillFile = await fileExists(skillMdPath) ? skillMdPath : await fileExists(skillMdPathLower) ? skillMdPathLower : null;
         if (!skillFile)
           continue;
@@ -18182,14 +18426,14 @@ class SkillsManager {
     return skills;
   }
   async cloneRepo(url) {
-    const tempDir = await fs22.mkdtemp(join4(tmpdir(), "agentinit-skills-"));
-    await fs22.rm(tempDir, { recursive: true, force: true });
+    const tempDir = await fs24.mkdtemp(join5(tmpdir(), "agentinit-skills-"));
+    await fs24.rm(tempDir, { recursive: true, force: true });
     try {
       await execFileAsync("git", ["clone", "--depth", "1", url, tempDir], {
         timeout: 60000
       });
     } catch (error) {
-      await fs22.rm(tempDir, { recursive: true, force: true }).catch(() => {
+      await fs24.rm(tempDir, { recursive: true, force: true }).catch(() => {
       });
       throw new Error(`Failed to clone ${url}: ${error.message}`);
     }
@@ -18283,7 +18527,7 @@ class SkillsManager {
       return { skills, warnings };
     } finally {
       if (tempDir) {
-        await fs22.rm(tempDir, { recursive: true, force: true }).catch(() => {
+        await fs24.rm(tempDir, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -18304,30 +18548,30 @@ class SkillsManager {
   async installSkill(skillPath, skillName, targetDir, copy = false) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
     const destPath = this.resolveInstallPath(targetDir, normalizedSkillName);
-    await fs22.mkdir(resolve8(targetDir), { recursive: true });
+    await fs24.mkdir(resolve8(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs22.rm(destPath, { recursive: true, force: true });
+      await fs24.rm(destPath, { recursive: true, force: true });
     }
     if (copy) {
       await this.copyDir(skillPath, destPath);
     } else {
-      await fs22.symlink(skillPath, destPath, "dir");
+      await fs24.symlink(skillPath, destPath, "dir");
     }
     return destPath;
   }
   async installSkillFromContent(skillName, skillContent, targetDir) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
     const destPath = this.resolveInstallPath(targetDir, normalizedSkillName);
-    await fs22.mkdir(resolve8(targetDir), { recursive: true });
+    await fs24.mkdir(resolve8(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs22.rm(destPath, { recursive: true, force: true });
+      await fs24.rm(destPath, { recursive: true, force: true });
     }
-    await fs22.mkdir(destPath, { recursive: true });
-    await fs22.writeFile(join4(destPath, "SKILL.md"), skillContent, "utf8");
+    await fs24.mkdir(destPath, { recursive: true });
+    await fs24.writeFile(join5(destPath, "SKILL.md"), skillContent, "utf8");
     return destPath;
   }
   getCanonicalSkillsDir(projectPath, global3 = false) {
-    return global3 ? resolve8(homedir4(), ".agents/skills") : resolve8(projectPath, ".agents/skills");
+    return global3 ? resolve8(homedir5(), ".agents/skills") : resolve8(projectPath, ".agents/skills");
   }
   async getInstallPlan(skillName, agent, projectPath, options2 = {}) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
@@ -18401,7 +18645,7 @@ class SkillsManager {
       throw new Error(`Missing canonical path for ${skillName}`);
     }
     await this.cleanAndCreateDirectory(canonicalPath);
-    await fs22.writeFile(join4(canonicalPath, "SKILL.md"), skillContent, "utf8");
+    await fs24.writeFile(join5(canonicalPath, "SKILL.md"), skillContent, "utf8");
     if (plan.path === canonicalPath) {
       return plan;
     }
@@ -18438,16 +18682,16 @@ class SkillsManager {
     return this.resolveInstallPath(targetDir, this.normalizeSkillName(skillName));
   }
   async cleanAndCreateDirectory(path) {
-    await fs22.rm(path, { recursive: true, force: true }).catch(() => {
+    await fs24.rm(path, { recursive: true, force: true }).catch(() => {
     });
-    await fs22.mkdir(path, { recursive: true });
+    await fs24.mkdir(path, { recursive: true });
   }
   isWithinPath(basePath, targetPath) {
     const relativePath = relative3(resolve8(basePath), resolve8(targetPath));
     return relativePath === "" || !relativePath.startsWith("..") && !relativePath.includes("/../") && !relativePath.includes("\\..\\");
   }
   async copyDir(src, dest) {
-    await fs22.cp(src, dest, { recursive: true, dereference: true });
+    await fs24.cp(src, dest, { recursive: true, dereference: true });
   }
   async addFromSource(source, projectPath, options2 = {}) {
     const discovered = await this.discoverFromSource(source, projectPath, {
@@ -18522,11 +18766,11 @@ class SkillsManager {
           continue;
         const entries = await listFiles(dir);
         for (const entry of entries) {
-          const entryPath = join4(dir, entry);
+          const entryPath = join5(dir, entry);
           if (!await isDirectory(entryPath))
             continue;
-          const skillMdPath = join4(entryPath, "SKILL.md");
-          const skillMdPathLower = join4(entryPath, "skill.md");
+          const skillMdPath = join5(entryPath, "SKILL.md");
+          const skillMdPathLower = join5(entryPath, "skill.md");
           const skillFile = await fileExists(skillMdPath) ? skillMdPath : await fileExists(skillMdPathLower) ? skillMdPathLower : null;
           if (!skillFile)
             continue;
@@ -18536,7 +18780,7 @@ class SkillsManager {
           let isSymlink = false;
           let canonicalPath;
           try {
-            const stat = await fs22.lstat(entryPath);
+            const stat = await fs24.lstat(entryPath);
             isSymlink = stat.isSymbolicLink();
             const canonicalBase = this.getCanonicalSkillsDir(projectPath, scope === "global");
             const [resolvedEntryPath, resolvedCanonicalBase] = await Promise.all([
@@ -18602,7 +18846,7 @@ class SkillsManager {
       }
       if (!removedPaths.has(entry.path)) {
         try {
-          await fs22.rm(entry.path, { recursive: true, force: true });
+          await fs24.rm(entry.path, { recursive: true, force: true });
           removedPaths.add(entry.path);
         } catch {
           skipped.push({
@@ -18615,7 +18859,7 @@ class SkillsManager {
       if (entry.canonicalPath && entry.canonicalPath !== entry.path && !removedCanonicalPaths.has(entry.canonicalPath)) {
         const stillReferenced = remainingEntries.some((other) => other.name.toLowerCase() === entry.name.toLowerCase() && other.canonicalPath === entry.canonicalPath);
         if (!stillReferenced) {
-          await fs22.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
+          await fs24.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
           });
           removedCanonicalPaths.add(entry.canonicalPath);
         }
@@ -24851,27 +25095,27 @@ var require_windows = __commonJS((exports, module) => {
     return checkPathExt(path, options2);
   };
   var isexe = function(path, options2, cb) {
-    fs29.stat(path, function(er, stat) {
+    fs31.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, path, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs29.statSync(path), path, options2);
+    return checkStat(fs31.statSync(path), path, options2);
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs29 = __require("fs");
+  var fs31 = __require("fs");
 });
 
 // node_modules/isexe/mode.js
 var require_mode = __commonJS((exports, module) => {
   var isexe = function(path, options2, cb) {
-    fs29.stat(path, function(er, stat) {
+    fs31.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs29.statSync(path), options2);
+    return checkStat(fs31.statSync(path), options2);
   };
   var checkStat = function(stat, options2) {
     return stat.isFile() && checkMode(stat, options2);
@@ -24891,7 +25135,7 @@ var require_mode = __commonJS((exports, module) => {
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs29 = __require("fs");
+  var fs31 = __require("fs");
 });
 
 // node_modules/isexe/index.js
@@ -24936,7 +25180,7 @@ var require_isexe = __commonJS((exports, module) => {
       }
     }
   };
-  var fs29 = __require("fs");
+  var fs31 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -25143,14 +25387,14 @@ var require_readShebang = __commonJS((exports, module) => {
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs29.openSync(command, "r");
-      fs29.readSync(fd, buffer, 0, size, 0);
-      fs29.closeSync(fd);
+      fd = fs31.openSync(command, "r");
+      fs31.readSync(fd, buffer, 0, size, 0);
+      fs31.closeSync(fd);
     } catch (e) {
     }
     return shebangCommand(buffer.toString());
   };
-  var fs29 = __require("fs");
+  var fs31 = __require("fs");
   var shebangCommand = require_shebang_command();
   module.exports = readShebang;
 });
@@ -27484,7 +27728,7 @@ import {relative as relative5} from "path";
 
 // dist/core/propagator.js
 var import_gray_matter3 = __toESM(require_gray_matter(), 1);
-import {promises as fs24} from "fs";
+import {promises as fs26} from "fs";
 import {resolve as resolve9} from "path";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -30252,7 +30496,7 @@ class Propagator {
       resolvedTargets: []
     };
     const exists = await fileExists(generatedFile.path);
-    const existingStats = exists ? await fs24.lstat(generatedFile.path).catch(() => null) : null;
+    const existingStats = exists ? await fs26.lstat(generatedFile.path).catch(() => null) : null;
     const existingContent = exists && !existingStats?.isSymbolicLink() ? await readFileIfExists(generatedFile.path) : null;
     const existingTarget = existingStats?.isSymbolicLink() ? await readSymlinkTarget(generatedFile.path) : null;
     if (options2.managedState && !options2.dryRun) {
@@ -30283,7 +30527,7 @@ class Propagator {
     if (!options2.dryRun) {
       if (generatedFile.kind === "file") {
         if (existingStats?.isSymbolicLink()) {
-          await fs24.rm(generatedFile.path, { force: true }).catch(() => {
+          await fs26.rm(generatedFile.path, { force: true }).catch(() => {
           });
         }
         await writeFile(generatedFile.path, generatedFile.content || "");
@@ -30460,14 +30704,14 @@ ${content}
 
 // dist/core/managedState.js
 init_fs();
-import {promises as fs26} from "fs";
-import {dirname as dirname3, join as join5, relative as relative4, resolve as resolve10} from "path";
+import {promises as fs28} from "fs";
+import {dirname as dirname3, join as join6, relative as relative4, resolve as resolve10} from "path";
 var toPosixPath = function(value) {
   return value.replace(/\\/g, "/");
 };
 async function pathType(targetPath) {
   try {
-    const stat = await fs26.lstat(targetPath);
+    const stat = await fs28.lstat(targetPath);
     if (stat.isSymbolicLink()) {
       return "symlink";
     }
@@ -30477,20 +30721,20 @@ async function pathType(targetPath) {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs26.mkdir(dest, { recursive: true });
-  const entries = await fs26.readdir(src, { withFileTypes: true });
+  await fs28.mkdir(dest, { recursive: true });
+  const entries = await fs28.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join5(src, entry.name);
-    const destPath = join5(dest, entry.name);
+    const srcPath = join6(src, entry.name);
+    const destPath = join6(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else if (entry.isSymbolicLink()) {
-      const target = await fs26.readlink(srcPath);
-      await fs26.mkdir(dirname3(destPath), { recursive: true });
-      await fs26.symlink(target, destPath);
+      const target = await fs28.readlink(srcPath);
+      await fs28.mkdir(dirname3(destPath), { recursive: true });
+      await fs28.symlink(target, destPath);
     } else {
-      await fs26.mkdir(dirname3(destPath), { recursive: true });
-      await fs26.copyFile(srcPath, destPath);
+      await fs28.mkdir(dirname3(destPath), { recursive: true });
+      await fs28.copyFile(srcPath, destPath);
     }
   }
 }
@@ -30499,14 +30743,14 @@ async function copyPath(src, dest) {
   if (!type2) {
     return;
   }
-  await fs26.mkdir(dirname3(dest), { recursive: true });
+  await fs28.mkdir(dirname3(dest), { recursive: true });
   if (type2 === "symlink") {
-    const target = await fs26.readlink(src);
-    await fs26.symlink(target, dest);
+    const target = await fs28.readlink(src);
+    await fs28.symlink(target, dest);
   } else if (type2 === "directory") {
     await copyDirectory(src, dest);
   } else {
-    await fs26.copyFile(src, dest);
+    await fs28.copyFile(src, dest);
   }
 }
 var MANAGED_STATE_FILE = "managed-state.json";
@@ -30520,11 +30764,11 @@ class ManagedStateStore {
     this.state = state;
   }
   static async open(projectPath) {
-    const agentInitDir = join5(projectPath, ".agentinit");
-    const statePath = join5(agentInitDir, MANAGED_STATE_FILE);
+    const agentInitDir = join6(projectPath, ".agentinit");
+    const statePath = join6(agentInitDir, MANAGED_STATE_FILE);
     const emptyState = { version: 1, entries: [] };
     try {
-      const raw = await fs26.readFile(statePath, "utf8");
+      const raw = await fs28.readFile(statePath, "utf8");
       const parsed = JSON.parse(raw);
       if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) {
         return new ManagedStateStore(projectPath, emptyState);
@@ -30535,13 +30779,13 @@ class ManagedStateStore {
     }
   }
   get agentInitDir() {
-    return join5(this.projectPath, ".agentinit");
+    return join6(this.projectPath, ".agentinit");
   }
   get stateFilePath() {
-    return join5(this.agentInitDir, MANAGED_STATE_FILE);
+    return join6(this.agentInitDir, MANAGED_STATE_FILE);
   }
   get backupsDir() {
-    return join5(this.agentInitDir, BACKUPS_DIR);
+    return join6(this.agentInitDir, BACKUPS_DIR);
   }
   normalizeRelativePath(targetPath, preserveTrailingSlash = false) {
     const hasTrailingSlash = preserveTrailingSlash && /[\\/]$/.test(targetPath);
@@ -30563,14 +30807,14 @@ class ManagedStateStore {
     }
     if (type2 === "symlink") {
       try {
-        const backupLinkTarget = await fs26.readlink(targetPath);
+        const backupLinkTarget = await fs28.readlink(targetPath);
         return { backupLinkTarget };
       } catch {
         return {};
       }
     }
     const relativeTargetPath = this.normalizeRelativePath(targetPath);
-    const backupPath = join5(this.backupsDir, relativeTargetPath);
+    const backupPath = join6(this.backupsDir, relativeTargetPath);
     if (!await fileExists(backupPath)) {
       await copyPath(targetPath, backupPath);
     }
@@ -30617,8 +30861,8 @@ class ManagedStateStore {
     return [...paths5];
   }
   async save() {
-    await fs26.mkdir(this.agentInitDir, { recursive: true });
-    await fs26.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
+    await fs28.mkdir(this.agentInitDir, { recursive: true });
+    await fs28.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
   }
   async revertAll(options2 = {}) {
     const summary = {
@@ -30633,29 +30877,29 @@ class ManagedStateStore {
       const backupLinkTarget = entry.backupLinkTarget;
       if (entry.existedBefore && backupLinkTarget !== undefined) {
         if (!options2.dryRun) {
-          await fs26.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
-          await fs26.mkdir(dirname3(absolutePath), { recursive: true });
-          await fs26.symlink(backupLinkTarget, absolutePath);
+          await fs28.mkdir(dirname3(absolutePath), { recursive: true });
+          await fs28.symlink(backupLinkTarget, absolutePath);
         }
         summary.restored++;
       } else if (entry.existedBefore && backupPath && await fileExists(backupPath)) {
         if (!options2.dryRun) {
-          await fs26.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
           await copyPath(backupPath, absolutePath);
         }
         summary.restored++;
       } else {
         if (!options2.dryRun) {
-          await fs26.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.removed++;
       }
       if (!options2.keepBackups && backupPath && await fileExists(backupPath)) {
         if (!options2.dryRun) {
-          await fs26.rm(backupPath, { recursive: true, force: true }).catch(() => {
+          await fs28.rm(backupPath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.backupsRemoved++;
@@ -30663,16 +30907,16 @@ class ManagedStateStore {
     }
     if (!options2.dryRun) {
       this.state.entries.length = 0;
-      await fs26.rm(this.stateFilePath, { force: true }).catch(() => {
+      await fs28.rm(this.stateFilePath, { force: true }).catch(() => {
       });
       if (!options2.keepBackups) {
-        await fs26.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
+        await fs28.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
         });
       }
       try {
-        const remainingEntries = await fs26.readdir(this.agentInitDir);
+        const remainingEntries = await fs28.readdir(this.agentInitDir);
         if (remainingEntries.length === 0) {
-          await fs26.rm(this.agentInitDir, { recursive: true, force: true });
+          await fs28.rm(this.agentInitDir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -31015,15 +31259,15 @@ class MCPParser {
 }
 
 // dist/constants/mcp.js
-import {readFileSync} from "fs";
+import {readFileSync as readFileSync2} from "fs";
 import {fileURLToPath} from "url";
-import {dirname as dirname4, join as join6} from "path";
+import {dirname as dirname4, join as join7} from "path";
 var getPackageVersion = function() {
   try {
     const __filename2 = fileURLToPath(import.meta.url);
     const __dirname2 = dirname4(__filename2);
-    const packageJsonPath = join6(__dirname2, "../../package.json");
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const packageJsonPath = join7(__dirname2, "../../package.json");
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
     return packageJson.version || "1.0.0";
   } catch {
     return "1.0.0";
@@ -31049,13 +31293,13 @@ var TOKEN_COUNT_THRESHOLDS = {
 };
 // dist/core/rulesParser.js
 init_fs();
-import {readFileSync as readFileSync3} from "fs";
+import {readFileSync as readFileSync4} from "fs";
 
 // dist/core/rulesTemplateLoader.js
 var toml = __toESM(require_toml(), 1);
 import {resolve as resolve11, dirname as dirname5} from "path";
 import {fileURLToPath as fileURLToPath2} from "url";
-import {readFileSync as readFileSync2, readdirSync, existsSync} from "fs";
+import {readFileSync as readFileSync3, readdirSync, existsSync as existsSync2} from "fs";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname5(__filename2);
 
@@ -31067,14 +31311,14 @@ class RulesTemplateLoader {
     this.loadTemplates();
   }
   loadTemplates() {
-    if (!existsSync(this.templatesPath)) {
+    if (!existsSync2(this.templatesPath)) {
       throw new Error(`Rules templates directory not found: ${this.templatesPath}`);
     }
     const files = readdirSync(this.templatesPath).filter((file) => file.endsWith(".toml"));
     for (const file of files) {
       try {
         const filePath = resolve11(this.templatesPath, file);
-        const content = readFileSync2(filePath, "utf-8");
+        const content = readFileSync3(filePath, "utf-8");
         const parsed = toml.default.parse(content);
         const template = {
           id: parsed.template.id,
@@ -31222,7 +31466,7 @@ class RulesParser {
       throw new RulesParseError(`Rules file not found: ${filePath}`);
     }
     try {
-      const content = readFileSync3(filePath, "utf-8");
+      const content = readFileSync4(filePath, "utf-8");
       if (filePath.endsWith(".json")) {
         const parsed = JSON.parse(content);
         return this.extractRulesFromObject(parsed);
@@ -39292,8 +39536,8 @@ class MCPVerifier {
 }
 
 // dist/core/gitignoreManager.js
-import {promises as fs29} from "fs";
-import {dirname as dirname6, join as join7} from "path";
+import {promises as fs31} from "fs";
+import {dirname as dirname6, join as join8} from "path";
 var normalizeIgnorePath = function(projectPath, value) {
   const relative6 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
   const normalized = relative6.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -39340,12 +39584,12 @@ var updateManagedBlock = function(existingContent, entries) {
   return content;
 };
 async function updateManagedIgnoreFile(projectPath, paths5, options2 = {}) {
-  const ignoreFile = options2.local ? join7(".git", "info", "exclude") : ".gitignore";
-  const ignoreFilePath = join7(projectPath, ignoreFile);
+  const ignoreFile = options2.local ? join8(".git", "info", "exclude") : ".gitignore";
+  const ignoreFilePath = join8(projectPath, ignoreFile);
   if (options2.local) {
-    const gitDir = join7(projectPath, ".git");
+    const gitDir = join8(projectPath, ".git");
     try {
-      const stat = await fs29.stat(gitDir);
+      const stat = await fs31.stat(gitDir);
       if (!stat.isDirectory()) {
         throw new Error;
       }
@@ -39356,21 +39600,21 @@ async function updateManagedIgnoreFile(projectPath, paths5, options2 = {}) {
   const normalizedPaths = [...new Set(paths5.map((path) => normalizeIgnorePath(projectPath, path)).filter(Boolean))].sort();
   let existingContent = "";
   try {
-    existingContent = await fs29.readFile(ignoreFilePath, "utf8");
+    existingContent = await fs31.readFile(ignoreFilePath, "utf8");
   } catch {
     existingContent = "";
   }
   const updatedContent = updateManagedBlock(existingContent, normalizedPaths);
-  await fs29.mkdir(dirname6(ignoreFilePath), { recursive: true });
-  await fs29.writeFile(ignoreFilePath, updatedContent, "utf8");
+  await fs31.mkdir(dirname6(ignoreFilePath), { recursive: true });
+  await fs31.writeFile(ignoreFilePath, updatedContent, "utf8");
   return ignoreFilePath;
 }
 async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
-  const ignoreFile = options2.local ? join7(".git", "info", "exclude") : ".gitignore";
-  const ignoreFilePath = join7(projectPath, ignoreFile);
+  const ignoreFile = options2.local ? join8(".git", "info", "exclude") : ".gitignore";
+  const ignoreFilePath = join8(projectPath, ignoreFile);
   let content;
   try {
-    content = await fs29.readFile(ignoreFilePath, "utf8");
+    content = await fs31.readFile(ignoreFilePath, "utf8");
   } catch {
     return false;
   }
@@ -39386,13 +39630,13 @@ async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
   const afterBlock = content.slice(endIndex + END_MARKER.length).replace(/^\n+/, "");
   let nextContent = `${beforeBlock}${afterBlock}`.replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
   if (nextContent.trim() === "") {
-    await fs29.rm(ignoreFilePath, { force: true }).catch(() => {
+    await fs31.rm(ignoreFilePath, { force: true }).catch(() => {
     });
   } else {
     if (!nextContent.endsWith("\n")) {
       nextContent += "\n";
     }
-    await fs29.writeFile(ignoreFilePath, nextContent, "utf8");
+    await fs31.writeFile(ignoreFilePath, nextContent, "utf8");
   }
   return true;
 }
@@ -39403,12 +39647,12 @@ var END_MARKER = "# END AgentInit Generated Files";
 init_agentManager();
 init_skillsManager();
 init_fs();
-import {dirname as dirname7, join as join8} from "path";
+import {dirname as dirname7, join as join9} from "path";
 async function discoverProjectSkills(projectPath, skillsManager4) {
   const sources = [];
   const skills = new Map;
   for (const sourceDir of PROJECT_SKILL_SOURCE_DIRS) {
-    const absoluteSourceDir = join8(projectPath, sourceDir);
+    const absoluteSourceDir = join9(projectPath, sourceDir);
     if (!await fileExists(absoluteSourceDir)) {
       continue;
     }
@@ -40300,9 +40544,197 @@ async function revertCommand(options2) {
   }
 }
 
+// dist/utils/colors.js
+var colorsEnabled = function() {
+  const env2 = process.env || {};
+  const isTTY2 = !!process.stdout?.isTTY;
+  return !env2.NODE_DISABLE_COLORS && env2.NO_COLOR == null && env2.TERM !== "dumb" && (env2.FORCE_COLOR != null && env2.FORCE_COLOR !== "0" || isTTY2);
+};
+function orange(text) {
+  if (!colorsEnabled()) {
+    return text;
+  }
+  return `\x1B[38;5;208m${text}\x1B[39m`;
+}
+
+// dist/commands/config.js
+init_marketplaceRegistry();
+init_userConfig();
+var sortConfig = function(config) {
+  config.customMarketplaces.sort((left, right) => left.identifier.localeCompare(right.identifier));
+  config.verifiedGithubRepos.sort((left, right) => left.localeCompare(right));
+  return config;
+};
+var failConfigCommand = function(error) {
+  logger.error(error instanceof Error ? error.message : "Configuration update failed.");
+  process.exitCode = 1;
+};
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("Manage AgentInit user configuration");
+  const marketplaces = config.command("marketplaces").description("Manage configured marketplaces");
+  marketplaces.command("list").description("List built-in and custom marketplaces").action(async () => {
+    logger.titleBox("AgentInit  Configuration");
+    logger.section("Marketplaces");
+    const defaultMarketplace = getConfiguredDefaultMarketplaceId();
+    const marketplaceIds = getMarketplaceIds();
+    for (let i = 0;i < marketplaceIds.length; i++) {
+      const identifier = marketplaceIds[i];
+      const marketplace = getMarketplace(identifier);
+      if (!marketplace) {
+        continue;
+      }
+      const flags = [
+        BUILT_IN_MARKETPLACE_IDS.has(identifier) ? "built-in" : "custom",
+        defaultMarketplace === identifier ? "default" : null
+      ].filter(Boolean).join(", ");
+      logger.tree(`${cyan(identifier)} ${dim(`[${flags}]`)} ${marketplace.name} ${dim(`-> ${marketplace.repoUrl}`)}`, i === marketplaceIds.length - 1);
+    }
+    if (!defaultMarketplace) {
+      logger.info("No default marketplace configured.");
+    }
+  });
+  marketplaces.command("add <identifier> <repoUrl>").description("Add a custom marketplace").option("--name <displayName>", "Display name for this marketplace").option("--default", "Set this marketplace as the default").action(async (identifierArg, repoUrlArg, options2) => {
+    logger.titleBox("AgentInit  Configuration");
+    try {
+      const identifier = normalizeMarketplaceIdentifier(identifierArg);
+      const repoUrl = normalizeMarketplaceRepoUrl(repoUrlArg);
+      const configState = await readUserConfig();
+      if (BUILT_IN_MARKETPLACE_IDS.has(identifier)) {
+        throw new Error(`Marketplace "${identifier}" is built in and cannot be redefined.`);
+      }
+      if (configState.customMarketplaces.some((marketplace) => marketplace.identifier === identifier)) {
+        throw new Error(`Marketplace "${identifier}" already exists.`);
+      }
+      configState.customMarketplaces.push({
+        identifier,
+        name: normalizeMarketplaceName(options2.name, identifier),
+        repoUrl
+      });
+      if (options2.default) {
+        configState.defaultMarketplace = identifier;
+      }
+      await writeUserConfig(sortConfig(configState));
+      logger.success(`Added marketplace ${green(identifier)}.`);
+      logger.info(`  ${repoUrl}`);
+      if (options2.default) {
+        logger.info("  Set as the configured default marketplace.");
+      }
+    } catch (error) {
+      failConfigCommand(error);
+    }
+  });
+  marketplaces.command("remove <identifier>").description("Remove a custom marketplace").action(async (identifierArg) => {
+    logger.titleBox("AgentInit  Configuration");
+    try {
+      const identifier = normalizeMarketplaceIdentifier(identifierArg);
+      if (BUILT_IN_MARKETPLACE_IDS.has(identifier)) {
+        throw new Error(`Marketplace "${identifier}" is built in and cannot be removed.`);
+      }
+      const configState = await readUserConfig();
+      const nextMarketplaces = configState.customMarketplaces.filter((marketplace) => marketplace.identifier !== identifier);
+      if (nextMarketplaces.length === configState.customMarketplaces.length) {
+        throw new Error(`Marketplace "${identifier}" is not configured.`);
+      }
+      configState.customMarketplaces = nextMarketplaces;
+      const clearedDefault = configState.defaultMarketplace === identifier;
+      if (clearedDefault) {
+        delete configState.defaultMarketplace;
+      }
+      await writeUserConfig(sortConfig(configState));
+      logger.success(`Removed marketplace ${green(identifier)}.`);
+      if (clearedDefault) {
+        logger.info("  Cleared the configured default marketplace.");
+      }
+    } catch (error) {
+      failConfigCommand(error);
+    }
+  });
+  marketplaces.command("default <identifier>").description("Set the configured default marketplace").action(async (identifierArg) => {
+    logger.titleBox("AgentInit  Configuration");
+    try {
+      const identifier = normalizeMarketplaceIdentifier(identifierArg);
+      if (!getMarketplace(identifier)) {
+        throw new Error(`Unknown marketplace: ${identifier}. Available: ${getMarketplaceIds().join(", ")}`);
+      }
+      const configState = await readUserConfig();
+      configState.defaultMarketplace = identifier;
+      await writeUserConfig(sortConfig(configState));
+      logger.success(`Set ${green(identifier)} as the configured default marketplace.`);
+    } catch (error) {
+      failConfigCommand(error);
+    }
+  });
+  marketplaces.command("clear-default").description("Clear the configured default marketplace").action(async () => {
+    logger.titleBox("AgentInit  Configuration");
+    const configState = await readUserConfig();
+    if (!configState.defaultMarketplace) {
+      logger.info("No configured default marketplace to clear.");
+      return;
+    }
+    delete configState.defaultMarketplace;
+    await writeUserConfig(sortConfig(configState));
+    logger.success("Cleared the configured default marketplace.");
+  });
+  const verifiedRepos = config.command("verified-repos").description("Manage exact verified GitHub repositories");
+  verifiedRepos.command("list").description("List verified GitHub repositories").action(async () => {
+    logger.titleBox("AgentInit  Configuration");
+    logger.section("Verified GitHub Repos");
+    const configState = await readUserConfig();
+    const entries = [
+      ...getBuiltInVerifiedGithubRepos().map((repo) => ({ repo, builtIn: true })),
+      ...configState.verifiedGithubRepos.filter((repo) => !BUILT_IN_VERIFIED_REPOS.has(repo)).map((repo) => ({ repo, builtIn: false }))
+    ];
+    for (let i = 0;i < entries.length; i++) {
+      const entry = entries[i];
+      logger.tree(`${cyan(entry.repo)} ${dim(entry.builtIn ? "[built-in]" : "[custom]")}`, i === entries.length - 1);
+    }
+  });
+  verifiedRepos.command("add <repo>").description("Add an exact verified GitHub repo in owner/repo form").action(async (repoArg) => {
+    logger.titleBox("AgentInit  Configuration");
+    try {
+      const repo = normalizeGitHubRepoRef(repoArg);
+      if (BUILT_IN_VERIFIED_REPOS.has(repo)) {
+        logger.info(`${repo} is already verified by AgentInit.`);
+        return;
+      }
+      const configState = await readUserConfig();
+      if (configState.verifiedGithubRepos.includes(repo)) {
+        logger.info(`${repo} is already configured as verified.`);
+        return;
+      }
+      configState.verifiedGithubRepos.push(repo);
+      await writeUserConfig(sortConfig(configState));
+      logger.success(`Added verified GitHub repo ${green(repo)}.`);
+    } catch (error) {
+      failConfigCommand(error);
+    }
+  });
+  verifiedRepos.command("remove <repo>").description("Remove a custom verified GitHub repo").action(async (repoArg) => {
+    logger.titleBox("AgentInit  Configuration");
+    try {
+      const repo = normalizeGitHubRepoRef(repoArg);
+      if (BUILT_IN_VERIFIED_REPOS.has(repo)) {
+        throw new Error(`${repo} is built in and cannot be removed.`);
+      }
+      const configState = await readUserConfig();
+      const nextRepos = configState.verifiedGithubRepos.filter((entry) => entry !== repo);
+      if (nextRepos.length === configState.verifiedGithubRepos.length) {
+        throw new Error(`${repo} is not configured as verified.`);
+      }
+      configState.verifiedGithubRepos = nextRepos;
+      await writeUserConfig(sortConfig(configState));
+      logger.success(`Removed verified GitHub repo ${green(repo)}.`);
+    } catch (error) {
+      failConfigCommand(error);
+    }
+  });
+}
+var BUILT_IN_MARKETPLACE_IDS = new Set(MARKETPLACES.map((marketplace) => marketplace.id));
+var BUILT_IN_VERIFIED_REPOS = new Set(getBuiltInVerifiedGithubRepos());
+
 // dist/commands/skills.js
 var import_prompts2 = __toESM(require_prompts3(), 1);
-import {homedir as homedir5} from "os";
+import {homedir as homedir6} from "os";
 import {relative as relative7, resolve as resolve12} from "path";
 init_skillsManager();
 init_marketplaceRegistry();
@@ -40587,7 +41019,7 @@ var prependCanonicalGlobalGroup = function(agentManager9, projectPath, groups) {
 var formatSkillsDir = function(projectPath, dir) {
   const normalizedDir = dir.replace(/\\/g, "/").replace(/\/?$/, "/");
   const normalizedProjectPath = projectPath.replace(/\\/g, "/");
-  const normalizedHome = homedir5().replace(/\\/g, "/");
+  const normalizedHome = homedir6().replace(/\\/g, "/");
   if (normalizedDir.startsWith(`${normalizedProjectPath}/`)) {
     return `${relative7(projectPath, dir).replace(/\\/g, "/").replace(/\/?$/, "/")}`;
   }
@@ -40598,7 +41030,7 @@ var formatSkillsDir = function(projectPath, dir) {
 };
 var formatPromptPath = function(path) {
   const normalizedPath = path.replace(/\\/g, "/").replace(/\/?$/, "/");
-  const normalizedHome = homedir5().replace(/\\/g, "/");
+  const normalizedHome = homedir6().replace(/\\/g, "/");
   if (normalizedPath === `${normalizedHome}/`) {
     return "~/";
   }
@@ -40608,7 +41040,7 @@ var formatPromptPath = function(path) {
   return normalizedPath;
 };
 var getCanonicalGlobalSkillsDir = function() {
-  return resolve12(homedir5(), ".agents/skills");
+  return resolve12(homedir6(), ".agents/skills");
 };
 var getCanonicalGlobalSkillsDisplayPath = function() {
   return formatPromptPath(getCanonicalGlobalSkillsDir());
@@ -41550,25 +41982,12 @@ function registerRulesCommand(program2) {
 // dist/commands/plugins.js
 var import_prompts3 = __toESM(require_prompts3(), 1);
 import {dirname as dirname8, relative as relative8} from "path";
-
-// dist/utils/colors.js
-var colorsEnabled = function() {
-  const env2 = process.env || {};
-  const isTTY2 = !!process.stdout?.isTTY;
-  return !env2.NODE_DISABLE_COLORS && env2.NO_COLOR == null && env2.TERM !== "dumb" && (env2.FORCE_COLOR != null && env2.FORCE_COLOR !== "0" || isTTY2);
-};
-function orange(text) {
-  if (!colorsEnabled()) {
-    return text;
-  }
-  return `\x1B[38;5;208m${text}\x1B[39m`;
-}
-
-// dist/commands/plugins.js
 init_pluginManager();
 init_agentManager();
+init_marketplaceRegistry();
 function registerPluginsCommand(program2) {
   const marketplaceHelp = new PluginManager().getMarketplaceIds().join(", ");
+  const marketplaceCategoryHelp = getMarketplaceCategories().join(", ");
   const plugins = program2.command("plugins").description("Install agent-agnostic plugins from any marketplace or source");
   plugins.command("install <source>").description("Install a plugin from <marketplace>/<name>, a GitHub repo, or a local path").option("--from <marketplace>", `Marketplace source override (available: ${marketplaceHelp})`).option("-a, --agent <agents...>", "Target specific agent(s)").option("-g, --global", "Install globally").option("--copy-skills", "Copy plugin skills instead of using canonical symlink installs").option("-l, --list", "Preview plugin contents without installing").option("-y, --yes", "Skip confirmation prompts, auto-detect project-configured agents").action(async (source, options2) => {
     logger.titleBox("AgentInit  Plugins");
@@ -41686,17 +42105,17 @@ function registerPluginsCommand(program2) {
       logger.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   });
-  plugins.command("search [query]").description("Search marketplace plugins").option("--from <marketplace>", `Which marketplace to search (available: ${marketplaceHelp})`).option("--category <category>", "Filter: official, community").action(async (query, options2) => {
+  plugins.command("search [query]").description("Search marketplace plugins").option("--from <marketplace>", `Which marketplace to search (available: ${marketplaceHelp})`).option("--category <category>", `Filter by marketplace category (examples: ${marketplaceCategoryHelp})`).action(async (query, options2) => {
     logger.titleBox("AgentInit  Plugin Search");
     const pluginManager2 = new PluginManager;
-    if (!options2.from) {
+    const registryId = options2.from || getConfiguredDefaultMarketplaceId();
+    if (!registryId) {
       logger.info(`Please specify a marketplace with --from <marketplace>. Available: ${marketplaceHelp}`);
       logger.info("Examples:");
       logger.info("  agentinit plugins search --from claude");
       logger.info("  agentinit plugins search code-review --from claude");
       return;
     }
-    const registryId = options2.from;
     const spinner = ora(`Fetching ${registryId} marketplace...`).start();
     try {
       const results = await pluginManager2.listMarketplacePlugins(registryId, query, options2.category);
@@ -42111,6 +42530,7 @@ registerSkillsCommand(program2);
 registerMcpCommand(program2);
 registerRulesCommand(program2);
 registerPluginsCommand(program2);
+registerConfigCommand(program2);
 program2.command("init").description("Initialize agents.md configuration for the current project").option("-f, --force", "Overwrite existing configuration").option("-t, --template <template>", "Use specific template (web, cli, library)").action(initCommand);
 program2.command("detect").description("Detect current project stack and existing agent configurations").option("-v, --verbose", "Show detailed detection results").action(detectCommand);
 program2.command("sync").description("Sync agents.md with agent-specific configuration files").option("-a, --agent <agents...>", "Target specific agent(s)").option("-d, --dry-run", "Show what would be changed without making changes").option("-b, --backup", "Create backup before syncing").action(syncCommand);