agentinit 1.13.4 → 1.15.0

package/dist/cli.js

@@ -8510,6 +8510,74 @@ async function createRelativeSymlink(target, linkPath) {
 var init_fs = __esm(() => {
 });
 
+// dist/utils/paths.js
+import {resolve as resolve2, join as join2} from "path";
+import {homedir} from "os";
+function getHomeDirectory() {
+  return homedir();
+}
+function getPlatform() {
+  switch (process.platform) {
+    case "win32":
+      return "windows";
+    case "darwin":
+      return "darwin";
+    case "linux":
+      return "linux";
+    default:
+      return "linux";
+  }
+}
+function expandTilde(path) {
+  if (path.startsWith("~/")) {
+    return join2(getHomeDirectory(), path.slice(2));
+  }
+  if (path === "~") {
+    return getHomeDirectory();
+  }
+  return path;
+}
+function getEnvironmentPath(key) {
+  return process.env[key];
+}
+function resolveGlobalConfigPath(globalConfigPath, globalConfigPaths) {
+  if (globalConfigPath) {
+    return expandTilde(globalConfigPath);
+  }
+  if (globalConfigPaths) {
+    const platform2 = getPlatform();
+    const platformPath = globalConfigPaths[platform2];
+    if (platformPath) {
+      return expandTilde(platformPath);
+    }
+  }
+  return null;
+}
+function getWindowsAppDataPaths() {
+  return {
+    roaming: getEnvironmentPath("APPDATA"),
+    local: getEnvironmentPath("LOCALAPPDATA"),
+    userProfile: getEnvironmentPath("USERPROFILE")
+  };
+}
+function resolveEnvironmentVariables(path) {
+  if (getPlatform() === "windows") {
+    const appDataPaths = getWindowsAppDataPaths();
+    return path.replace(/%APPDATA%/g, appDataPaths.roaming || "").replace(/%LOCALAPPDATA%/g, appDataPaths.local || "").replace(/%USERPROFILE%/g, appDataPaths.userProfile || "");
+  }
+  return path;
+}
+function getFullGlobalConfigPath(globalConfigPath, globalConfigPaths) {
+  const path = resolveGlobalConfigPath(globalConfigPath, globalConfigPaths);
+  if (!path) {
+    return null;
+  }
+  const resolvedPath = resolveEnvironmentVariables(path);
+  return resolve2(resolvedPath);
+}
+var init_paths = __esm(() => {
+});
+
 // node_modules/kind-of/index.js
 var require_kind_of = __commonJS((exports, module) => {
   var ctorName = function(val) {
@@ -11935,74 +12003,6 @@ var require_gray_matter = __commonJS((exports, module) => {
   module.exports = matter;
 });
 
-// dist/utils/paths.js
-import {resolve as resolve5, join as join2} from "path";
-import {homedir} from "os";
-function getHomeDirectory() {
-  return homedir();
-}
-function getPlatform() {
-  switch (process.platform) {
-    case "win32":
-      return "windows";
-    case "darwin":
-      return "darwin";
-    case "linux":
-      return "linux";
-    default:
-      return "linux";
-  }
-}
-function expandTilde(path) {
-  if (path.startsWith("~/")) {
-    return join2(getHomeDirectory(), path.slice(2));
-  }
-  if (path === "~") {
-    return getHomeDirectory();
-  }
-  return path;
-}
-function getEnvironmentPath(key) {
-  return process.env[key];
-}
-function resolveGlobalConfigPath(globalConfigPath, globalConfigPaths) {
-  if (globalConfigPath) {
-    return expandTilde(globalConfigPath);
-  }
-  if (globalConfigPaths) {
-    const platform2 = getPlatform();
-    const platformPath = globalConfigPaths[platform2];
-    if (platformPath) {
-      return expandTilde(platformPath);
-    }
-  }
-  return null;
-}
-function getWindowsAppDataPaths() {
-  return {
-    roaming: getEnvironmentPath("APPDATA"),
-    local: getEnvironmentPath("LOCALAPPDATA"),
-    userProfile: getEnvironmentPath("USERPROFILE")
-  };
-}
-function resolveEnvironmentVariables(path) {
-  if (getPlatform() === "windows") {
-    const appDataPaths = getWindowsAppDataPaths();
-    return path.replace(/%APPDATA%/g, appDataPaths.roaming || "").replace(/%LOCALAPPDATA%/g, appDataPaths.local || "").replace(/%USERPROFILE%/g, appDataPaths.userProfile || "");
-  }
-  return path;
-}
-function getFullGlobalConfigPath(globalConfigPath, globalConfigPaths) {
-  const path = resolveGlobalConfigPath(globalConfigPath, globalConfigPaths);
-  if (!path) {
-    return null;
-  }
-  const resolvedPath = resolveEnvironmentVariables(path);
-  return resolve5(resolvedPath);
-}
-var init_paths = __esm(() => {
-});
-
 // node_modules/contextcalc/dist/lib/index.js
 import {get_encoding} from "tiktoken";
 async function isBinaryFile(filePath) {
@@ -12389,6 +12389,9 @@ class Agent {
   get name() {
     return this.definition.name;
   }
+  getDetectionScope() {
+    return this.definition.detectionScope || "project";
+  }
   get capabilities() {
     return this.definition.capabilities;
   }
@@ -15899,6 +15902,140 @@ var init_CopilotAgent = __esm(() => {
   init_fs();
 });
 
+// dist/agents/OpenClawAgent.js
+class OpenClawAgent extends Agent {
+  constructor() {
+    const definition = {
+      id: "openclaw",
+      name: "OpenClaw",
+      capabilities: {
+        mcp: {
+          stdio: false,
+          http: false,
+          sse: false
+        },
+        rules: false,
+        hooks: false,
+        commands: false,
+        subagents: false,
+        statusline: false,
+        skills: true
+      },
+      configFiles: [],
+      nativeConfigPath: ".openclaw/config.json",
+      detectionScope: "environment",
+      skillPaths: {
+        project: ".agents/skills/",
+        global: "~/.openclaw/skills/"
+      },
+      projectStandards: {
+        skills: "agents"
+      }
+    };
+    super(definition);
+  }
+  async detectPresence(_projectPath) {
+    const openClawHome = expandTilde("~/.openclaw");
+    if (!await fileExists(openClawHome)) {
+      return null;
+    }
+    return {
+      agent: this,
+      configPath: openClawHome
+    };
+  }
+  async applyMCPConfig(_projectPath, _servers) {
+    throw new Error("OpenClaw does not support MCP configuration.");
+  }
+  async removeMCPServer(_projectPath, _serverName) {
+    throw new Error("OpenClaw does not support MCP configuration.");
+  }
+  async applyRulesConfig(_configPath, _rules, _existingContent) {
+    throw new Error("OpenClaw does not support rules configuration.");
+  }
+  extractExistingRules(_content) {
+    return [];
+  }
+  extractExistingSections(_content) {
+    return [];
+  }
+  generateRulesContent(_sections) {
+    return "";
+  }
+}
+var init_OpenClawAgent = __esm(() => {
+  init_Agent();
+  init_fs();
+  init_paths();
+});
+
+// dist/agents/HermesAgent.js
+class HermesAgent extends Agent {
+  constructor() {
+    const definition = {
+      id: "hermes",
+      name: "Hermes",
+      capabilities: {
+        mcp: {
+          stdio: false,
+          http: false,
+          sse: false
+        },
+        rules: false,
+        hooks: false,
+        commands: false,
+        subagents: false,
+        statusline: false,
+        skills: true
+      },
+      configFiles: [],
+      nativeConfigPath: ".hermes/config.json",
+      detectionScope: "environment",
+      skillPaths: {
+        project: ".agents/skills/",
+        global: "~/.hermes/skills/"
+      },
+      projectStandards: {
+        skills: "agents"
+      }
+    };
+    super(definition);
+  }
+  async detectPresence(_projectPath) {
+    const hermesHome = expandTilde("~/.hermes");
+    if (!await fileExists(hermesHome)) {
+      return null;
+    }
+    return {
+      agent: this,
+      configPath: hermesHome
+    };
+  }
+  async applyMCPConfig(_projectPath, _servers) {
+    throw new Error("Hermes does not support MCP configuration.");
+  }
+  async removeMCPServer(_projectPath, _serverName) {
+    throw new Error("Hermes does not support MCP configuration.");
+  }
+  async applyRulesConfig(_configPath, _rules, _existingContent) {
+    throw new Error("Hermes does not support rules configuration.");
+  }
+  extractExistingRules(_content) {
+    return [];
+  }
+  extractExistingSections(_content) {
+    return [];
+  }
+  generateRulesContent(_sections) {
+    return "";
+  }
+}
+var init_HermesAgent = __esm(() => {
+  init_Agent();
+  init_fs();
+  init_paths();
+});
+
 // dist/agents/AiderAgent.js
 class AiderAgent extends MarkdownRulesAgent {
   constructor() {
@@ -16493,7 +16630,9 @@ class AgentManager {
       new WindsurfAgent,
       new RooCodeAgent,
       new ZedAgent,
-      new DroidAgent
+      new DroidAgent,
+      new OpenClawAgent,
+      new HermesAgent
     ];
   }
   getAllAgents() {
@@ -16505,9 +16644,18 @@ class AgentManager {
   getSupportedAgentIds() {
     return this.agents.map((agent) => agent.id);
   }
-  async detectAgents(projectPath) {
+  shouldIncludeForDetection(agent, options2) {
+    if (options2.includeEnvironment) {
+      return true;
+    }
+    return agent.getDetectionScope() !== "environment";
+  }
+  async detectAgents(projectPath, options2 = {}) {
     const results = [];
     for (const agent of this.agents) {
+      if (!this.shouldIncludeForDetection(agent, options2)) {
+        continue;
+      }
       const detection = await agent.detectPresence(projectPath);
       if (detection) {
         results.push(detection);
@@ -16515,27 +16663,30 @@ class AgentManager {
     }
     return results;
   }
-  async detectAgentById(projectPath, agentId) {
+  async detectAgentById(projectPath, agentId, options2 = {}) {
     const agent = this.getAgentById(agentId);
     if (!agent) {
       return null;
     }
+    if (!this.shouldIncludeForDetection(agent, options2)) {
+      return null;
+    }
     return await agent.detectPresence(projectPath);
   }
-  async getPrimaryAgent(projectPath) {
-    const detectedAgents = await this.detectAgents(projectPath);
+  async getPrimaryAgent(projectPath, options2 = {}) {
+    const detectedAgents = await this.detectAgents(projectPath, options2);
     return detectedAgents.length > 0 ? detectedAgents[0] : null;
   }
   registerAgent(agent) {
     this.agents = this.agents.filter((existing) => existing.id !== agent.id);
     this.agents.push(agent);
   }
-  async hasAnyAgents(projectPath) {
-    const detected = await this.detectAgents(projectPath);
+  async hasAnyAgents(projectPath, options2 = {}) {
+    const detected = await this.detectAgents(projectPath, options2);
     return detected.length > 0;
   }
-  async getDetectionSummary(projectPath) {
-    const detected = await this.detectAgents(projectPath);
+  async getDetectionSummary(projectPath, options2 = {}) {
+    const detected = await this.detectAgents(projectPath, options2);
     if (detected.length === 0) {
       return "No AI coding agents detected in this project.";
     }
@@ -16557,6 +16708,8 @@ var init_agentManager = __esm(() => {
   init_CursorAgent();
   init_DroidAgent();
   init_CopilotAgent();
+  init_OpenClawAgent();
+  init_HermesAgent();
   init_AiderAgent();
   init_ClineAgent();
   init_WindsurfAgent();
@@ -16564,15 +16717,191 @@ 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 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);
 }
-var MARKETPLACES;
+function getConfiguredDefaultMarketplaceId() {
+  const defaultMarketplace = readUserConfigSync().defaultMarketplace;
+  if (!defaultMarketplace) {
+    return;
+  }
+  return getMarketplace(defaultMarketplace)?.id;
+}
+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",
@@ -16596,6 +16925,8 @@ var init_marketplaceRegistry = __esm(() => {
       cacheTtlMs: 3600000
     }
   ];
+  CUSTOM_MARKETPLACE_PLUGIN_DIRS = ["skills", "mcps", "rules"];
+  CUSTOM_MARKETPLACE_CACHE_TTL_MS = 3600000;
 });
 
 // dist/core/mcpFilter.js
@@ -16707,9 +17038,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 fs18} 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;
@@ -16743,7 +17074,7 @@ class PluginManager {
   }
   async cleanupLoadedPluginContext(context) {
     if (context?.tempDir) {
-      await fs18.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
+      await fs22.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -16814,8 +17145,14 @@ class PluginManager {
     }
     return `https://github.com/${source.owner}/${source.repo}`;
   }
+  getGitHubFallbackTrust(source) {
+    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: [] };
     }
@@ -16894,12 +17231,13 @@ class PluginManager {
           throw error;
         }
         const fallbackUrl = this.formatGitHubRepoUrl(fallbackSource) || fallbackSource.url.replace(/\.git$/, "");
+        const fallbackTrust = this.getGitHubFallbackTrust(fallbackSource);
         resolutionWarnings.push(error.message);
-        resolutionWarnings.push(`Marketplace lookup failed; trying unverified GitHub repository ${fallbackUrl} instead.`);
+        resolutionWarnings.push(`Marketplace lookup failed; trying ${fallbackTrust} GitHub repository ${fallbackUrl} instead.`);
         try {
           tempDir = await this.skillsManager.cloneRepo(fallbackSource.url);
         } catch (fallbackError) {
-          throw new Error(`${error.message} Tried unverified GitHub repository ${fallbackUrl} but failed: ${fallbackError instanceof Error ? fallbackError.message : "Unknown error"}`);
+          throw new Error(`${error.message} Tried ${fallbackTrust} GitHub repository ${fallbackUrl} but failed: ${fallbackError instanceof Error ? fallbackError.message : "Unknown error"}`);
         }
         effectiveSource = {
           ...fallbackSource,
@@ -16955,13 +17293,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"] : [],
@@ -16977,7 +17315,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;
     }
@@ -16997,7 +17335,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
     };
   }
@@ -17070,10 +17408,10 @@ class PluginManager {
       warnings.push(`Skipped native Claude plugin install because Claude already has "${plugin.name}" installed as ${conflictingKey}.`);
       return { installed, skipped, warnings };
     }
-    await fs18.rm(nativeTarget.installPath, { recursive: true, force: true }).catch(() => {
+    await fs22.rm(nativeTarget.installPath, { recursive: true, force: true }).catch(() => {
     });
-    await fs18.mkdir(dirname2(nativeTarget.installPath), { recursive: true });
-    await fs18.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",
@@ -17121,7 +17459,7 @@ class PluginManager {
       claudeSettings.enabledPlugins = remainingEnabledPlugins;
       await this.saveClaudeSettings(claudeSettings);
     }
-    await fs18.rm(component.installPath, { recursive: true, force: true }).catch(() => {
+    await fs22.rm(component.installPath, { recursive: true, force: true }).catch(() => {
     });
     return true;
   }
@@ -17172,7 +17510,7 @@ class PluginManager {
         repo
       };
     }
-    const defaultMarketplace = this.getMarketplaceIds()[0];
+    const defaultMarketplace = getConfiguredDefaultMarketplaceId() || this.getMarketplaceIds()[0];
     if (defaultMarketplace) {
       return {
         type: "marketplace",
@@ -17191,13 +17529,13 @@ 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");
+    const cacheMetaPath = join4(cacheDir, ".agentinit-cache-meta.json");
     if (await fileExists(cacheMetaPath)) {
       try {
-        const meta = JSON.parse(await fs18.readFile(cacheMetaPath, "utf8"));
+        const meta = JSON.parse(await fs22.readFile(cacheMetaPath, "utf8"));
         const age = Date.now() - (meta.fetchedAt || 0);
         if (age < registry.cacheTtlMs) {
           return cacheDir;
@@ -17205,29 +17543,29 @@ class PluginManager {
       } catch {
       }
     }
-    if (await fileExists(join3(cacheDir, ".git"))) {
+    if (await fileExists(join4(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 fs18.rm(cacheDir, { recursive: true, force: true });
+        await fs22.rm(cacheDir, { recursive: true, force: true });
         await this.cloneMarketplace(registry.repoUrl, cacheDir);
       }
     } else {
       await this.cloneMarketplace(registry.repoUrl, cacheDir);
     }
-    await fs18.mkdir(cacheDir, { recursive: true });
-    await fs18.writeFile(cacheMetaPath, JSON.stringify({ fetchedAt: Date.now() }));
+    await fs22.mkdir(cacheDir, { recursive: true });
+    await fs22.writeFile(cacheMetaPath, JSON.stringify({ fetchedAt: Date.now() }));
     return cacheDir;
   }
   async cloneMarketplace(repoUrl, dest) {
-    await fs18.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 fs18.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 });
   }
@@ -17237,7 +17575,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;
       }
@@ -17253,7 +17591,7 @@ 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;
@@ -17263,26 +17601,26 @@ class PluginManager {
       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 fs18.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 fs18.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)
@@ -17290,10 +17628,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 fs18.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(", ")}`;
@@ -17315,10 +17653,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";
@@ -17335,7 +17673,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}`);
@@ -17346,10 +17684,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 {
@@ -17364,7 +17702,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}`);
@@ -17403,7 +17741,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 [];
@@ -17450,7 +17788,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))
@@ -17459,7 +17797,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);
@@ -17748,7 +18086,7 @@ ${body.trim()}
       }
       if (!removedSkillPaths.has(skill.path)) {
         try {
-          await fs18.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}`);
@@ -17757,7 +18095,7 @@ ${body.trim()}
       }
       if (skill.canonicalPath && skill.canonicalPath !== skill.path && !removedCanonicalPaths.has(skill.canonicalPath) && !sharedCanonicalPath) {
         try {
-          await fs18.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}`);
@@ -17861,27 +18199,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 fs20} 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";
 
@@ -17948,6 +18287,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",
@@ -17984,7 +18334,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)) {
@@ -17992,7 +18342,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)) {
@@ -18004,11 +18354,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;
@@ -18022,14 +18372,14 @@ class SkillsManager {
     return skills;
   }
   async cloneRepo(url) {
-    const tempDir = await fs20.mkdtemp(join4(tmpdir(), "agentinit-skills-"));
-    await fs20.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 fs20.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}`);
     }
@@ -18123,7 +18473,7 @@ class SkillsManager {
       return { skills, warnings };
     } finally {
       if (tempDir) {
-        await fs20.rm(tempDir, { recursive: true, force: true }).catch(() => {
+        await fs24.rm(tempDir, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -18144,30 +18494,30 @@ class SkillsManager {
   async installSkill(skillPath, skillName, targetDir, copy = false) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
     const destPath = this.resolveInstallPath(targetDir, normalizedSkillName);
-    await fs20.mkdir(resolve8(targetDir), { recursive: true });
+    await fs24.mkdir(resolve8(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs20.rm(destPath, { recursive: true, force: true });
+      await fs24.rm(destPath, { recursive: true, force: true });
     }
     if (copy) {
       await this.copyDir(skillPath, destPath);
     } else {
-      await fs20.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 fs20.mkdir(resolve8(targetDir), { recursive: true });
+    await fs24.mkdir(resolve8(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs20.rm(destPath, { recursive: true, force: true });
+      await fs24.rm(destPath, { recursive: true, force: true });
     }
-    await fs20.mkdir(destPath, { recursive: true });
-    await fs20.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);
@@ -18241,7 +18591,7 @@ class SkillsManager {
       throw new Error(`Missing canonical path for ${skillName}`);
     }
     await this.cleanAndCreateDirectory(canonicalPath);
-    await fs20.writeFile(join4(canonicalPath, "SKILL.md"), skillContent, "utf8");
+    await fs24.writeFile(join5(canonicalPath, "SKILL.md"), skillContent, "utf8");
     if (plan.path === canonicalPath) {
       return plan;
     }
@@ -18278,16 +18628,16 @@ class SkillsManager {
     return this.resolveInstallPath(targetDir, this.normalizeSkillName(skillName));
   }
   async cleanAndCreateDirectory(path) {
-    await fs20.rm(path, { recursive: true, force: true }).catch(() => {
+    await fs24.rm(path, { recursive: true, force: true }).catch(() => {
     });
-    await fs20.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 fs20.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, {
@@ -18362,11 +18712,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;
@@ -18376,7 +18726,7 @@ class SkillsManager {
           let isSymlink = false;
           let canonicalPath;
           try {
-            const stat = await fs20.lstat(entryPath);
+            const stat = await fs24.lstat(entryPath);
             isSymlink = stat.isSymbolicLink();
             const canonicalBase = this.getCanonicalSkillsDir(projectPath, scope === "global");
             const [resolvedEntryPath, resolvedCanonicalBase] = await Promise.all([
@@ -18442,7 +18792,7 @@ class SkillsManager {
       }
       if (!removedPaths.has(entry.path)) {
         try {
-          await fs20.rm(entry.path, { recursive: true, force: true });
+          await fs24.rm(entry.path, { recursive: true, force: true });
           removedPaths.add(entry.path);
         } catch {
           skipped.push({
@@ -18455,7 +18805,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 fs20.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
+          await fs24.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
           });
           removedCanonicalPaths.add(entry.canonicalPath);
         }
@@ -19869,7 +20219,7 @@ var require_util3 = __commonJS((exports, module) => {
     var path = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
     return joinPaths(currentPath, path);
   };
-  var getData = function($data, lvl, paths2) {
+  var getData = function($data, lvl, paths5) {
     var up, jsonPointer, data, matches;
     if ($data === "")
       return "rootData";
@@ -19887,7 +20237,7 @@ var require_util3 = __commonJS((exports, module) => {
       if (jsonPointer == "#") {
         if (up >= lvl)
           throw new Error("Cannot access property/index " + up + " levels up, current level is " + lvl);
-        return paths2[lvl - up];
+        return paths5[lvl - up];
       }
       if (up > lvl)
         throw new Error("Cannot access data " + up + " levels up, current level is " + lvl);
@@ -24691,27 +25041,27 @@ var require_windows = __commonJS((exports, module) => {
     return checkPathExt(path, options2);
   };
   var isexe = function(path, options2, cb) {
-    fs27.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(fs27.statSync(path), path, options2);
+    return checkStat(fs31.statSync(path), path, options2);
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs27 = __require("fs");
+  var fs31 = __require("fs");
 });
 
 // node_modules/isexe/mode.js
 var require_mode = __commonJS((exports, module) => {
   var isexe = function(path, options2, cb) {
-    fs27.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(fs27.statSync(path), options2);
+    return checkStat(fs31.statSync(path), options2);
   };
   var checkStat = function(stat, options2) {
     return stat.isFile() && checkMode(stat, options2);
@@ -24731,7 +25081,7 @@ var require_mode = __commonJS((exports, module) => {
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs27 = __require("fs");
+  var fs31 = __require("fs");
 });
 
 // node_modules/isexe/index.js
@@ -24776,7 +25126,7 @@ var require_isexe = __commonJS((exports, module) => {
       }
     }
   };
-  var fs27 = __require("fs");
+  var fs31 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -24983,14 +25333,14 @@ var require_readShebang = __commonJS((exports, module) => {
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs27.openSync(command, "r");
-      fs27.readSync(fd, buffer, 0, size, 0);
-      fs27.closeSync(fd);
+      fd = fs31.openSync(command, "r");
+      fs31.readSync(fd, buffer, 0, size, 0);
+      fs31.closeSync(fd);
     } catch (e) {
     }
     return shebangCommand(buffer.toString());
   };
-  var fs27 = __require("fs");
+  var fs31 = __require("fs");
   var shebangCommand = require_shebang_command();
   module.exports = readShebang;
 });
@@ -25142,7 +25492,7 @@ var {
 } = import_.default;
 
 // dist/commands/init.js
-import {resolve as resolve4} from "path";
+import {resolve as resolve5} from "path";
 
 // node_modules/ora/index.js
 import process9 from "node:process";
@@ -26493,7 +26843,45 @@ var bgMagenta = init(45, 49);
 var bgCyan = init(46, 49);
 var bgWhite = init(47, 49);
 
+// dist/utils/symbols.js
+var STATUS = {
+  success: "\u2713",
+  error: "\u2717",
+  warning: "\u26A0",
+  info: "\u2139",
+  debug: "\u2022"
+};
+var TREE = {
+  branch: "\u251C\u2500",
+  last: "\u2514\u2500"
+};
+var BOX = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502"
+};
+
 // dist/utils/logger.js
+var getTerminalWidth = function() {
+  const columns = process.stdout.columns;
+  return typeof columns === "number" && columns > 0 ? columns : 80;
+};
+var truncateText = function(text, maxLength) {
+  if (maxLength <= 0) {
+    return "";
+  }
+  if (text.length <= maxLength) {
+    return text;
+  }
+  if (maxLength <= 3) {
+    return ".".repeat(maxLength);
+  }
+  return `${text.slice(0, maxLength - 3)}...`;
+};
+
 class Logger {
   static instance;
   static getInstance() {
@@ -26503,22 +26891,22 @@ class Logger {
     return Logger.instance;
   }
   info(message) {
-    console.log(cyan("\u2139"), message);
+    console.log(cyan(STATUS.info), message);
   }
   success(message) {
-    console.log(green("\u2713"), message);
+    console.log(green(STATUS.success), message);
   }
   warning(message) {
-    console.log(yellow("\u26A0"), message);
+    console.log(yellow(STATUS.warning), message);
   }
   warn(message) {
     this.warning(message);
   }
   error(message) {
-    console.log(red("\u2717"), message);
+    console.log(red(STATUS.error), message);
   }
   debug(message) {
-    console.log(dim("\u2022"), dim(message));
+    console.log(dim(STATUS.debug), dim(message));
   }
   title(message) {
     console.log(bold(cyan(message)));
@@ -26526,6 +26914,30 @@ class Logger {
   subtitle(message) {
     console.log(bold(message));
   }
+  titleBox(message) {
+    const w = getTerminalWidth();
+    if (w < 8) {
+      console.log(bold(cyan(truncateText(message, w))));
+      return;
+    }
+    const maxInner = Math.max(4, w - 2);
+    const inner = Math.min(Math.max(message.length + 4, 40), maxInner);
+    const visibleMessage = truncateText(message, inner - 2);
+    const padR = Math.max(0, inner - visibleMessage.length - 2);
+    console.log(dim(BOX.topLeft + BOX.horizontal.repeat(inner) + BOX.topRight));
+    console.log(dim(BOX.vertical) + " " + bold(cyan(visibleMessage)) + " ".repeat(padR) + " " + dim(BOX.vertical));
+    console.log(dim(BOX.bottomLeft + BOX.horizontal.repeat(inner) + BOX.bottomRight));
+  }
+  section(title) {
+    const w = getTerminalWidth();
+    const lineLen = Math.max(0, w - title.length - 5);
+    console.log("");
+    console.log(bold(`${BOX.horizontal}${BOX.horizontal} ${title} ${BOX.horizontal.repeat(lineLen)}`));
+  }
+  tree(message, isLast) {
+    const connector = isLast ? TREE.last : TREE.branch;
+    console.log(`${connector} ${message}`);
+  }
 }
 var logger = Logger.getInstance();
 
@@ -26534,7 +26946,8 @@ init_fs();
 
 // dist/core/agentDetector.js
 init_fs();
-import {resolve as resolve2} from "path";
+init_paths();
+import {isAbsolute, resolve as resolve3} from "path";
 
 class AgentDetector {
   agentConfigs = [
@@ -26545,14 +26958,19 @@ class AgentDetector {
     { name: "codeium", files: [".codeium/config.json"] },
     { name: "codex", files: [".codex/config.toml"] },
     { name: "gemini", files: [".gemini/settings.json"] },
+    { name: "openclaw", files: ["~/.openclaw"], scope: "environment" },
+    { name: "hermes", files: ["~/.hermes"], scope: "environment" },
     { name: "aider", files: [".aider.conf.yml"] },
     { name: "cline", files: [".clinerules"] },
     { name: "roo", files: [".roo/mcp.json"] },
     { name: "zed", files: [".zed/settings.json"] }
   ];
-  async detectAgents(projectPath) {
+  async detectAgents(projectPath, options2 = {}) {
     const results = [];
     for (const config of this.agentConfigs) {
+      if (!this.shouldCheckScope(config.scope, options2)) {
+        continue;
+      }
       const detected = await this.checkAgentFiles(projectPath, config.files);
       results.push({
         name: config.name,
@@ -26563,19 +26981,41 @@ class AgentDetector {
     }
     return results;
   }
+  shouldCheckScope(scope, options2) {
+    if (options2.includeEnvironment) {
+      return true;
+    }
+    return scope !== "environment";
+  }
   async checkAgentFiles(projectPath, files) {
     for (const file of files) {
-      const fullPath = resolve2(projectPath, file);
+      const fullPath = this.resolveDetectionPath(projectPath, file);
       if (await fileExists(fullPath)) {
         return { found: true, path: fullPath };
       }
     }
     return { found: false };
   }
-  async detectAgentByName(projectPath, agentName) {
+  resolveDetectionPath(projectPath, file) {
+    if (file.startsWith("~")) {
+      return expandTilde(file);
+    }
+    if (isAbsolute(file)) {
+      return file;
+    }
+    return resolve3(projectPath, file);
+  }
+  async detectAgentByName(projectPath, agentName, options2 = {}) {
     const config = this.agentConfigs.find((c) => c.name === agentName);
     if (!config)
       return null;
+    if (!this.shouldCheckScope(config.scope, options2)) {
+      return {
+        name: config.name,
+        files: config.files,
+        detected: false
+      };
+    }
     const detected = await this.checkAgentFiles(projectPath, config.files);
     return {
       name: config.name,
@@ -26591,7 +27031,7 @@ class AgentDetector {
 
 // dist/core/stackDetector.js
 init_fs();
-import {resolve as resolve3} from "path";
+import {resolve as resolve4} from "path";
 
 class StackDetector {
   lockFiles = [
@@ -26637,7 +27077,7 @@ class StackDetector {
   }
   async detectFromLockFiles(projectPath) {
     for (const lockFile of this.lockFiles) {
-      const lockPath = resolve3(projectPath, lockFile);
+      const lockPath = resolve4(projectPath, lockFile);
       if (await fileExists(lockPath)) {
         return this.inferStackFromLockFile(projectPath, lockFile);
       }
@@ -26669,7 +27109,7 @@ class StackDetector {
   }
   async detectFromManifests(projectPath) {
     for (const manifest of this.manifestFiles) {
-      const manifestPath = resolve3(projectPath, manifest);
+      const manifestPath = resolve4(projectPath, manifest);
       if (await fileExists(manifestPath)) {
         return this.inferStackFromManifest(projectPath, manifest);
       }
@@ -26701,7 +27141,7 @@ class StackDetector {
   }
   async detectFromConfigs(projectPath) {
     for (const config of this.configFiles) {
-      const configPath = resolve3(projectPath, config);
+      const configPath = resolve4(projectPath, config);
       if (await fileExists(configPath)) {
         return this.inferStackFromConfig(projectPath, config);
       }
@@ -26760,7 +27200,7 @@ class StackDetector {
     };
   }
   async analyzeJavaScriptProject(projectPath) {
-    const packageJsonPath = resolve3(projectPath, "package.json");
+    const packageJsonPath = resolve4(projectPath, "package.json");
     const packageJsonContent = await readFileIfExists(packageJsonPath);
     const info = {
       language: "javascript",
@@ -26775,7 +27215,7 @@ class StackDetector {
         ...packageJson.devDependencies
       };
       info.dependencies = Object.keys(allDeps);
-      if (allDeps.typescript || await fileExists(resolve3(projectPath, "tsconfig.json"))) {
+      if (allDeps.typescript || await fileExists(resolve4(projectPath, "tsconfig.json"))) {
         info.language = "typescript";
       }
       if (allDeps.next)
@@ -26792,11 +27232,11 @@ class StackDetector {
         info.framework = "express";
       else if (allDeps.fastify)
         info.framework = "fastify";
-      if (await fileExists(resolve3(projectPath, "yarn.lock")))
+      if (await fileExists(resolve4(projectPath, "yarn.lock")))
         info.packageManager = "yarn";
-      else if (await fileExists(resolve3(projectPath, "pnpm-lock.yaml")))
+      else if (await fileExists(resolve4(projectPath, "pnpm-lock.yaml")))
         info.packageManager = "pnpm";
-      else if (await fileExists(resolve3(projectPath, "bun.lockb")))
+      else if (await fileExists(resolve4(projectPath, "bun.lockb")))
         info.packageManager = "bun";
       else
         info.packageManager = "npm";
@@ -27075,8 +27515,8 @@ This is a {{STACK}} project{{FRAMEWORK_CONTEXT}}. The codebase follows modern de
 // dist/commands/init.js
 async function initCommand(options2) {
   const cwd = process.cwd();
-  const agentsPath = resolve4(cwd, "agents.md");
-  logger.title("\uD83D\uDE80 AgentInit - Initialize Project");
+  const agentsPath = resolve5(cwd, "agents.md");
+  logger.titleBox("AgentInit  Initialize Project");
   if (!options2.force && await fileExists(agentsPath)) {
     const response = await import_prompts.default({
       type: "confirm",
@@ -27153,7 +27593,7 @@ async function initCommand(options2) {
 }
 var getProjectName = function(cwd) {
   try {
-    const packageJsonPath = resolve4(cwd, "package.json");
+    const packageJsonPath = resolve5(cwd, "package.json");
     const packageJson = __require(packageJsonPath);
     return packageJson.name || cwd.split("/").pop() || "project";
   } catch {
@@ -27166,7 +27606,7 @@ init_skillsManager();
 init_agentManager();
 async function detectCommand(options2) {
   const cwd = process.cwd();
-  logger.title("\uD83D\uDD0D AgentInit - Project Detection");
+  logger.titleBox("AgentInit  Project Detection");
   const spinner = ora("Detecting project configuration...").start();
   try {
     const agentDetector3 = new AgentDetector;
@@ -27234,7 +27674,7 @@ import {relative as relative5} from "path";
 
 // dist/core/propagator.js
 var import_gray_matter3 = __toESM(require_gray_matter(), 1);
-import {promises as fs22} from "fs";
+import {promises as fs26} from "fs";
 import {resolve as resolve9} from "path";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -30002,7 +30442,7 @@ class Propagator {
       resolvedTargets: []
     };
     const exists = await fileExists(generatedFile.path);
-    const existingStats = exists ? await fs22.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) {
@@ -30033,7 +30473,7 @@ class Propagator {
     if (!options2.dryRun) {
       if (generatedFile.kind === "file") {
         if (existingStats?.isSymbolicLink()) {
-          await fs22.rm(generatedFile.path, { force: true }).catch(() => {
+          await fs26.rm(generatedFile.path, { force: true }).catch(() => {
           });
         }
         await writeFile(generatedFile.path, generatedFile.content || "");
@@ -30210,14 +30650,14 @@ ${content}
 
 // dist/core/managedState.js
 init_fs();
-import {promises as fs24} 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 fs24.lstat(targetPath);
+    const stat = await fs28.lstat(targetPath);
     if (stat.isSymbolicLink()) {
       return "symlink";
     }
@@ -30227,20 +30667,20 @@ async function pathType(targetPath) {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs24.mkdir(dest, { recursive: true });
-  const entries = await fs24.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 fs24.readlink(srcPath);
-      await fs24.mkdir(dirname3(destPath), { recursive: true });
-      await fs24.symlink(target, destPath);
+      const target = await fs28.readlink(srcPath);
+      await fs28.mkdir(dirname3(destPath), { recursive: true });
+      await fs28.symlink(target, destPath);
     } else {
-      await fs24.mkdir(dirname3(destPath), { recursive: true });
-      await fs24.copyFile(srcPath, destPath);
+      await fs28.mkdir(dirname3(destPath), { recursive: true });
+      await fs28.copyFile(srcPath, destPath);
     }
   }
 }
@@ -30249,14 +30689,14 @@ async function copyPath(src, dest) {
   if (!type2) {
     return;
   }
-  await fs24.mkdir(dirname3(dest), { recursive: true });
+  await fs28.mkdir(dirname3(dest), { recursive: true });
   if (type2 === "symlink") {
-    const target = await fs24.readlink(src);
-    await fs24.symlink(target, dest);
+    const target = await fs28.readlink(src);
+    await fs28.symlink(target, dest);
   } else if (type2 === "directory") {
     await copyDirectory(src, dest);
   } else {
-    await fs24.copyFile(src, dest);
+    await fs28.copyFile(src, dest);
   }
 }
 var MANAGED_STATE_FILE = "managed-state.json";
@@ -30270,11 +30710,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 fs24.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);
@@ -30285,13 +30725,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);
@@ -30313,14 +30753,14 @@ class ManagedStateStore {
     }
     if (type2 === "symlink") {
       try {
-        const backupLinkTarget = await fs24.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);
     }
@@ -30355,20 +30795,20 @@ class ManagedStateStore {
     if (this.state.entries.length === 0) {
       return [];
     }
-    const paths2 = new Set([
+    const paths5 = new Set([
       ".agentinit/managed-state.json",
       ".agentinit/backups/"
     ]);
     for (const entry of this.state.entries) {
       if (entry.ignorePath) {
-        paths2.add(entry.ignorePath);
+        paths5.add(entry.ignorePath);
       }
     }
-    return [...paths2];
+    return [...paths5];
   }
   async save() {
-    await fs24.mkdir(this.agentInitDir, { recursive: true });
-    await fs24.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 = {
@@ -30383,29 +30823,29 @@ class ManagedStateStore {
       const backupLinkTarget = entry.backupLinkTarget;
       if (entry.existedBefore && backupLinkTarget !== undefined) {
         if (!options2.dryRun) {
-          await fs24.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
-          await fs24.mkdir(dirname3(absolutePath), { recursive: true });
-          await fs24.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 fs24.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 fs24.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 fs24.rm(backupPath, { recursive: true, force: true }).catch(() => {
+          await fs28.rm(backupPath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.backupsRemoved++;
@@ -30413,16 +30853,16 @@ class ManagedStateStore {
     }
     if (!options2.dryRun) {
       this.state.entries.length = 0;
-      await fs24.rm(this.stateFilePath, { force: true }).catch(() => {
+      await fs28.rm(this.stateFilePath, { force: true }).catch(() => {
       });
       if (!options2.keepBackups) {
-        await fs24.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
+        await fs28.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
         });
       }
       try {
-        const remainingEntries = await fs24.readdir(this.agentInitDir);
+        const remainingEntries = await fs28.readdir(this.agentInitDir);
         if (remainingEntries.length === 0) {
-          await fs24.rm(this.agentInitDir, { recursive: true, force: true });
+          await fs28.rm(this.agentInitDir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -30436,7 +30876,7 @@ init_agentManager();
 async function syncCommand(options2) {
   const cwd = process.cwd();
   const agentManager5 = new AgentManager;
-  logger.title("\uD83D\uDD04 AgentInit - Sync Configuration");
+  logger.titleBox("AgentInit  Sync");
   if (options2.dryRun) {
     logger.info("Running in dry-run mode - no files will be modified");
   }
@@ -30765,15 +31205,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";
@@ -30799,13 +31239,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);
 
@@ -30817,14 +31257,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,
@@ -30972,7 +31412,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);
@@ -38960,7 +39400,7 @@ class MCPVerifier {
     for (const result of results) {
       const { server, status, capabilities, error, connectionTime } = result;
       if (status === "success" && capabilities) {
-        output.push(`\u2705 MCP Server: ${server.name} (${server.type.toUpperCase()})`);
+        output.push(`\u2713 MCP Server: ${server.name} (${server.type.toUpperCase()})`);
         output.push(`   Status: Connected successfully (${connectionTime}ms)`);
         if (capabilities.serverInfo) {
           output.push(`   Version: ${capabilities.serverInfo.version}`);
@@ -39010,10 +39450,10 @@ class MCPVerifier {
           }
         }
         if (capabilities.tools.length === 0 && capabilities.resources.length === 0 && capabilities.prompts.length === 0) {
-          output.push(`   \u26A0\uFE0F  No tools, resources, or prompts available`);
+          output.push(`   \u26A0  No tools, resources, or prompts available`);
         }
       } else {
-        const statusIcon = status === "timeout" ? "\u23F1\uFE0F" : "\u274C";
+        const statusIcon = status === "timeout" ? "\u29D7" : "\u2717";
         output.push(`${statusIcon} MCP Server: ${server.name} (${server.type.toUpperCase()})`);
         output.push(`   Status: ${status === "timeout" ? "Connection timeout" : "Failed"} (${connectionTime || 0}ms)`);
         if (error) {
@@ -39042,8 +39482,8 @@ class MCPVerifier {
 }
 
 // dist/core/gitignoreManager.js
-import {promises as fs27} 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(/^\/+/, "");
@@ -39089,13 +39529,13 @@ var updateManagedBlock = function(existingContent, entries) {
   }
   return content;
 };
-async function updateManagedIgnoreFile(projectPath, paths2, options2 = {}) {
-  const ignoreFile = options2.local ? join7(".git", "info", "exclude") : ".gitignore";
-  const ignoreFilePath = join7(projectPath, ignoreFile);
+async function updateManagedIgnoreFile(projectPath, paths5, options2 = {}) {
+  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 fs27.stat(gitDir);
+      const stat = await fs31.stat(gitDir);
       if (!stat.isDirectory()) {
         throw new Error;
       }
@@ -39103,24 +39543,24 @@ async function updateManagedIgnoreFile(projectPath, paths2, options2 = {}) {
       throw new Error("Cannot update .git/info/exclude because this project is not a Git repository");
     }
   }
-  const normalizedPaths = [...new Set(paths2.map((path) => normalizeIgnorePath(projectPath, path)).filter(Boolean))].sort();
+  const normalizedPaths = [...new Set(paths5.map((path) => normalizeIgnorePath(projectPath, path)).filter(Boolean))].sort();
   let existingContent = "";
   try {
-    existingContent = await fs27.readFile(ignoreFilePath, "utf8");
+    existingContent = await fs31.readFile(ignoreFilePath, "utf8");
   } catch {
     existingContent = "";
   }
   const updatedContent = updateManagedBlock(existingContent, normalizedPaths);
-  await fs27.mkdir(dirname6(ignoreFilePath), { recursive: true });
-  await fs27.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 fs27.readFile(ignoreFilePath, "utf8");
+    content = await fs31.readFile(ignoreFilePath, "utf8");
   } catch {
     return false;
   }
@@ -39136,13 +39576,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 fs27.rm(ignoreFilePath, { force: true }).catch(() => {
+    await fs31.rm(ignoreFilePath, { force: true }).catch(() => {
     });
   } else {
     if (!nextContent.endsWith("\n")) {
       nextContent += "\n";
     }
-    await fs27.writeFile(ignoreFilePath, nextContent, "utf8");
+    await fs31.writeFile(ignoreFilePath, nextContent, "utf8");
   }
   return true;
 }
@@ -39153,12 +39593,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;
     }
@@ -39276,7 +39716,7 @@ async function applyProjectCommand(options2) {
   const cwd = process.cwd();
   const agentManager7 = new AgentManager;
   let managedState3 = null;
-  logger.title("\uD83D\uDD27 AgentInit - Apply");
+  logger.titleBox("AgentInit  Apply");
   if (options2.dryRun) {
     logger.info("Running in dry-run mode - no files will be modified");
   }
@@ -39400,7 +39840,7 @@ async function applyProjectCommand(options2) {
 }
 async function applyCommand(args) {
   const cwd = process.cwd();
-  logger.title("\uD83D\uDD27 AgentInit - Apply Configuration");
+  logger.titleBox("AgentInit  Apply Configuration");
   const hasMcpArgs = args.some((arg) => arg.startsWith("--mcp-"));
   const hasRulesArgs = args.some((arg) => arg === "--rules" || arg === "--rule-raw" || arg === "--rules-file" || arg === "--rules-remote");
   const clientArgIndex = args.findIndex((arg) => arg === "--client" || arg === "--agent");
@@ -39805,7 +40245,7 @@ var LEGACY_APPLY_FLAGS = new Set([
 init_agentManager();
 async function verifyMcpCommand(args) {
   const cwd = process.cwd();
-  logger.title("\uD83D\uDD0D AgentInit - MCP Verification");
+  logger.titleBox("AgentInit  MCP Verification");
   const hasAll = args.includes("--all");
   const mcpNameIndex = args.findIndex((arg) => arg === "--mcp-name");
   const mcpName = mcpNameIndex >= 0 && mcpNameIndex + 1 < args.length ? args[mcpNameIndex + 1] : null;
@@ -40009,7 +40449,7 @@ async function verifyMcpCommand(args) {
 // dist/commands/revert.js
 async function revertCommand(options2) {
   const cwd = process.cwd();
-  logger.title("\u21A9\uFE0F AgentInit - Revert");
+  logger.titleBox("AgentInit  Revert");
   if (options2.dryRun) {
     logger.info("Running in dry-run mode - no files will be modified");
   }
@@ -40050,9 +40490,193 @@ 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;
+};
+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) {
+      logger.error(error instanceof Error ? error.message : "Failed to add marketplace.");
+    }
+  });
+  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) {
+      logger.error(error instanceof Error ? error.message : "Failed to remove marketplace.");
+    }
+  });
+  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) {
+      logger.error(error instanceof Error ? error.message : "Failed to set default marketplace.");
+    }
+  });
+  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) {
+      logger.error(error instanceof Error ? error.message : "Failed to add verified repo.");
+    }
+  });
+  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) {
+      logger.error(error instanceof Error ? error.message : "Failed to remove verified repo.");
+    }
+  });
+}
+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();
@@ -40060,8 +40684,8 @@ init_agentManager();
 function registerSkillsCommand(program2) {
   const marketplaceHelp = getMarketplaceIds().join(", ");
   const skills = program2.command("skills").description("Manage agent skills");
-  skills.command("add <source>").description("Add skills from a marketplace, GitHub repo, or local path").option("--from <marketplace>", `Marketplace source override (available: ${marketplaceHelp})`).option("-g, --global", "Install skills globally").option("-a, --agent <agents...>", "Target specific agent(s)").option("-s, --skill <names...>", "Install only specific skills by name").option("-l, --list", "List available skills from the source without installing").option("--copy", "Copy skill files instead of symlinking").option("-y, --yes", "Skip prompts and auto-detect project agents only").action(async (source, options2) => {
-    logger.title("\uD83D\uDCE6 AgentInit - Skills");
+  skills.command("add <source>").description("Add skills from a marketplace, GitHub repo, or local path").option("--from <marketplace>", `Marketplace source override (available: ${marketplaceHelp})`).option("-g, --global", "Install skills globally").option("-a, --agent <agents...>", "Target specific agent(s)").option("-s, --skill <names...>", "Install only specific skills by name").option("-l, --list", "List available skills from the source without installing").option("--copy", "Copy skill files instead of symlinking").option("-y, --yes", "Skip prompts and auto-detect project-configured agents only").action(async (source, options2) => {
+    logger.titleBox("AgentInit  Skills");
     const agentManager9 = new AgentManager;
     const skillsManager5 = new SkillsManager(agentManager9);
     if (options2.list) {
@@ -40111,7 +40735,7 @@ function registerSkillsCommand(program2) {
     }
   });
   skills.command("list").alias("ls").description("List installed skills").option("-g, --global", "List only global skills").option("-a, --agent <agents...>", "Filter by specific agent(s)").action(async (options2) => {
-    logger.title("\uD83D\uDCE6 AgentInit - Skills");
+    logger.titleBox("AgentInit  Skills");
     const agentManager9 = new AgentManager;
     const skillsManager5 = new SkillsManager(agentManager9);
     const installed = await skillsManager5.listInstalled(process.cwd(), {
@@ -40151,7 +40775,7 @@ function registerSkillsCommand(program2) {
     }
   });
   skills.command("remove [names...]").alias("rm").description("Remove installed skills by name").option("-g, --global", "Remove from global scope").option("-a, --agent <agents...>", "Target specific agent(s)").option("-y, --yes", "Skip confirmation prompts").action(async (names, options2) => {
-    logger.title("\uD83D\uDCE6 AgentInit - Skills");
+    logger.titleBox("AgentInit  Skills");
     if (!names || names.length === 0) {
       if (!options2.yes) {
         logger.error("Please specify skill name(s) to remove.");
@@ -40337,7 +40961,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(/\/?$/, "/")}`;
   }
@@ -40348,7 +40972,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 "~/";
   }
@@ -40358,7 +40982,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());
@@ -41073,7 +41697,7 @@ var buildAppliedRules = function(sections) {
 function registerRulesCommand(program2) {
   const rules = program2.command("rules").description("Manage agent rules");
   rules.command("add").description("Add rules to agent configuration").option("-t, --template <templates...>", "Rule templates to apply (comma-separated values accepted)").option("-r, --raw <rules...>", "Raw rule strings").option("-f, --file <path>", "Load rules from a file").option("--remote <url>", "Load rules from a remote URL").option("--auth <token>", "Authentication token for remote rules (Bearer token)").option("-a, --agent <agents...>", "Target specific agent(s)").option("-g, --global", "Apply rules globally").action(async (options2) => {
-    logger.title("\uD83D\uDCCF AgentInit - Rules");
+    logger.titleBox("AgentInit  Rules");
     const cwd = process.cwd();
     const isGlobal = !!options2.global;
     const templates = [];
@@ -41201,7 +41825,7 @@ function registerRulesCommand(program2) {
     }
   });
   rules.command("list").alias("ls").description("List rules configured for each agent").option("-a, --agent <agents...>", "Filter by specific agent(s)").option("-g, --global", "List global rules").action(async (options2) => {
-    logger.title("\uD83D\uDCCF AgentInit - Rules");
+    logger.titleBox("AgentInit  Rules");
     const cwd = process.cwd();
     const isGlobal = !!options2.global;
     const agentManager11 = new AgentManager;
@@ -41241,7 +41865,7 @@ function registerRulesCommand(program2) {
     }
   });
   rules.command("remove [names...]").alias("rm").description("Remove rule sections by template ID (e.g. git, write_docs)").option("-a, --agent <agents...>", "Target specific agent(s)").option("-g, --global", "Remove from global rules").action(async (names, options2) => {
-    logger.title("\uD83D\uDCCF AgentInit - Rules");
+    logger.titleBox("AgentInit  Rules");
     if (!names || names.length === 0) {
       logger.error("Please specify rule section name(s) to remove.");
       logger.info("Usage: agentinit rules remove <name...>");
@@ -41302,11 +41926,12 @@ var import_prompts3 = __toESM(require_prompts3(), 1);
 import {dirname as dirname8, relative as relative8} from "path";
 init_pluginManager();
 init_agentManager();
+init_marketplaceRegistry();
 function registerPluginsCommand(program2) {
   const marketplaceHelp = new PluginManager().getMarketplaceIds().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 all agents").action(async (source, options2) => {
-    logger.title("\uD83D\uDD0C AgentInit - Plugins");
+  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");
     const agentManager12 = new AgentManager;
     const pluginManager2 = new PluginManager(agentManager12);
     if (options2.list) {
@@ -41422,16 +42047,16 @@ function registerPluginsCommand(program2) {
     }
   });
   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) => {
-    logger.title("\uD83D\uDD0C AgentInit - Plugin Search");
+    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);
@@ -41463,7 +42088,7 @@ function registerPluginsCommand(program2) {
     }
   });
   plugins.command("list").alias("ls").description("List installed plugins").option("-a, --agent <agents...>", "Filter by specific agent(s)").option("-g, --global", "List global plugins").action(async (options2) => {
-    logger.title("\uD83D\uDD0C AgentInit - Installed Plugins");
+    logger.titleBox("AgentInit  Installed Plugins");
     const pluginManager2 = new PluginManager;
     const installed = await pluginManager2.listPlugins(process.cwd(), {
       global: options2.global,
@@ -41499,7 +42124,7 @@ function registerPluginsCommand(program2) {
     }
   });
   plugins.command("remove <name>").alias("rm").description("Remove an installed plugin").option("-a, --agent <agents...>", "Target specific agent(s)").option("-g, --global", "Remove from global scope").option("-y, --yes", "Skip confirmation prompts").action(async (name, options2) => {
-    logger.title("\uD83D\uDD0C AgentInit - Remove Plugin");
+    logger.titleBox("AgentInit  Remove Plugin");
     const pluginManager2 = new PluginManager;
     const spinner = ora(`Removing plugin "${name}"...`).start();
     try {
@@ -41549,28 +42174,40 @@ var getPortableComponentSummary = function(preview) {
   return parts.length > 0 ? parts.join(", ") : "No portable components";
 };
 var getSourceWarnings = function(warnings) {
-  const lines = [];
+  const items = [];
   for (const warning of warnings) {
     const missingMatch = warning.match(/^Plugin "(.+)" not found in (.+) marketplace\.$/);
     if (missingMatch) {
-      lines.push(`${missingMatch[2]} marketplace does not contain "${missingMatch[1]}".`);
+      items.push({
+        type: "marketplace-miss",
+        text: `${missingMatch[2]} marketplace does not contain "${missingMatch[1]}".`
+      });
       continue;
     }
-    const fallbackMatch = warning.match(/^Marketplace lookup failed; trying unverified GitHub repository (.+) instead\.$/);
+    const fallbackMatch = warning.match(/^Marketplace lookup failed; trying (verified|unverified) GitHub repository (.+) instead\.$/);
     if (fallbackMatch) {
-      lines.push(`Falling back to unverified GitHub repository: ${fallbackMatch[1]}`);
+      items.push({
+        type: fallbackMatch[1] === "verified" ? "fallback-verified" : "fallback-unverified",
+        text: `${fallbackMatch[1] === "verified" ? "Verified" : "Unverified"} GitHub repository: ${fallbackMatch[2]}`
+      });
       continue;
     }
     const bundleMatch = warning.match(/^Source "(.+)" is a Claude Code marketplace bundle; using bundled plugin "(.+)"\.$/);
     if (bundleMatch) {
-      lines.push(`Claude Code marketplace bundle detected: ${bundleMatch[1]}`);
-      lines.push(`Using bundled plugin "${bundleMatch[2]}".`);
+      items.push({
+        type: "bundle-detected",
+        text: `Claude Code marketplace bundle detected: ${bundleMatch[1]}`
+      });
+      items.push({
+        type: "bundle-using",
+        text: `Using bundled plugin "${bundleMatch[2]}".`
+      });
     }
   }
-  return lines;
+  return items;
 };
 var getRemainingWarnings = function(warnings) {
-  return warnings.filter((warning) => !/^Plugin "(.+)" not found in (.+) marketplace\.$/.test(warning) && !/^Marketplace lookup failed; trying unverified GitHub repository (.+) instead\.$/.test(warning) && !/^Source "(.+)" is a Claude Code marketplace bundle; using bundled plugin "(.+)"\.$/.test(warning) && !/^Hooks \(hooks\/\) are Claude Code-specific$/.test(warning) && !/^Agent definitions \(agents\/\) are Claude Code-specific$/.test(warning) && !/^Claude Code-native plugin components detected \((.+)\);/.test(warning) && !/^Claude Code-native plugin components detected \((.+)\), but no Claude Code target was selected; skipped native install\.$/.test(warning) && warning !== "Reload plugins in Claude Code with /reload-plugins to activate native plugin components.");
+  return warnings.filter((warning) => !/^Plugin "(.+)" not found in (.+) marketplace\.$/.test(warning) && !/^Marketplace lookup failed; trying (verified|unverified) GitHub repository (.+) instead\.$/.test(warning) && !/^Source "(.+)" is a Claude Code marketplace bundle; using bundled plugin "(.+)"\.$/.test(warning) && !/^Hooks \(hooks\/\) are Claude Code-specific$/.test(warning) && !/^Agent definitions \(agents\/\) are Claude Code-specific$/.test(warning) && !/^Claude Code-native plugin components detected \((.+)\);/.test(warning) && !/^Claude Code-native plugin components detected \((.+)\), but no Claude Code target was selected; skipped native install\.$/.test(warning) && warning !== "Reload plugins in Claude Code with /reload-plugins to activate native plugin components.");
 };
 var getNativeCompatibilityWarning = function(previewOrResult) {
   if ("nativePreview" in previewOrResult) {
@@ -41606,33 +42243,67 @@ var renderPluginWarnings = function(previewOrResult, projectPath) {
   const allWarnings = "nativePreview" in previewOrResult ? previewOrResult.plugin.warnings : previewOrResult.warnings;
   const sourceWarnings = getSourceWarnings(previewOrResult.plugin.warnings);
   if (sourceWarnings.length > 0) {
-    console.log("");
-    logger.subtitle("Source");
-    for (const warning of sourceWarnings) {
-      logger.warn(`  ${warning}`);
+    logger.section("Source");
+    const lastIdx = sourceWarnings.length - 1;
+    for (let i = 0;i < sourceWarnings.length; i++) {
+      const item = sourceWarnings[i];
+      const isLast = i === lastIdx;
+      if (item.type === "marketplace-miss") {
+        logger.tree(yellow("\u26A0") + `  ${item.text}`, isLast);
+      } else if (item.type === "fallback-verified") {
+        logger.tree(green("\u2713") + `  ${item.text}`, isLast);
+      } else if (item.type === "fallback-unverified") {
+        logger.tree(yellow("\u26A0") + `  ${item.text}`, isLast);
+      } else if (item.type === "bundle-detected") {
+        logger.tree(orange("\u2713") + `  ${orange(item.text)}`, isLast);
+      } else if (item.type === "bundle-using") {
+        logger.tree(green("\u2713") + `  ${item.text}`, isLast);
+      }
     }
   }
   const nativeWarning = getNativeCompatibilityWarning(previewOrResult);
   if (nativeWarning) {
-    console.log("");
-    logger.subtitle("Compatibility");
-    logger.warn(`  Claude Code-only components detected: ${nativeWarning.features.join(", ")}`);
+    logger.section("Compatibility");
+    const lines = [];
+    lines.push({
+      text: orange("\u26A0") + `  ${orange("Claude Code")}-only components detected: ${dim(nativeWarning.features.join(", "))}`,
+      isLast: false
+    });
     if (nativeWarning.installPath) {
-      logger.info(`  Claude native install path: ${formatPathForDisplay(nativeWarning.installPath, projectPath)}`);
+      lines.push({
+        text: orange("\u2139") + `  ${orange("Claude")} native install path: ${dim(formatPathForDisplay(nativeWarning.installPath, projectPath))}`,
+        isLast: false
+      });
     }
     if (nativeWarning.skipped) {
-      logger.warn("  No Claude Code target selected. Native Claude installation was skipped.");
+      lines.push({
+        text: orange("\u26A0") + `  No ${orange("Claude Code")} target selected. Native installation was skipped.`,
+        isLast: true
+      });
     } else {
-      logger.info("  Non-Claude targets install only the portable skills and MCP servers.");
-      logger.info("nativePreview" in previewOrResult ? "  If you install to Claude Code, reload plugins with /reload-plugins afterward." : "  Reload plugins in Claude Code with /reload-plugins after install.");
+      lines.push({
+        text: cyan("\u2139") + "  Non-Claude targets install only the portable skills and MCP servers.",
+        isLast: false
+      });
+      const reloadMsg = "nativePreview" in previewOrResult ? `  If you install to ${orange("Claude Code")}, reload plugins with ${bold("/reload-plugins")} afterward.` : `  Reload plugins in ${orange("Claude Code")} with ${bold("/reload-plugins")} after install.`;
+      lines.push({
+        text: orange("\u2139") + reloadMsg,
+        isLast: true
+      });
+    }
+    if (lines.length > 0) {
+      lines[lines.length - 1].isLast = true;
+    }
+    for (const line of lines) {
+      logger.tree(line.text, line.isLast);
     }
   }
   const otherWarnings = getRemainingWarnings(allWarnings);
   if (otherWarnings.length > 0) {
-    console.log("");
-    logger.subtitle("Warnings");
-    for (const warning of otherWarnings) {
-      logger.warn(`  ${warning}`);
+    logger.section("Warnings");
+    const lastIdx = otherWarnings.length - 1;
+    for (let i = 0;i < otherWarnings.length; i++) {
+      logger.tree(yellow("\u26A0") + `  ${otherWarnings[i]}`, i === lastIdx);
     }
   }
 };
@@ -41646,34 +42317,55 @@ var renderInstalledComponents = function(result, agentManager12, projectPath) {
     skillGroups.set(targetDir, existing);
   }
   if (skillGroups.size > 0) {
-    logger.subtitle("Skills");
-    for (const [targetDir, data] of skillGroups) {
-      logger.info(`  ${getAgentLabel([...data.agents], agentManager12)}: ${green(String(data.skillNames.size))} skill(s) -> ${formatPathForDisplay(targetDir, projectPath)}`);
-    }
+    logger.section("Skills");
+    const entries = [...skillGroups.entries()];
     const copiedFallbacks = result.skills.installed.filter((item) => item.symlinkFailed);
+    const totalItems = entries.length + (copiedFallbacks.length > 0 ? 1 : 0);
+    let idx = 0;
+    for (const [targetDir, data] of entries) {
+      idx++;
+      const agentLabel = colorAgentLabel([...data.agents], agentManager12);
+      logger.tree(`${agentLabel}: ${green(String(data.skillNames.size))} skill(s) -> ${dim(formatPathForDisplay(targetDir, projectPath))}`, idx === totalItems);
+    }
     if (copiedFallbacks.length > 0) {
-      logger.warn(`  Symlink creation failed for ${copiedFallbacks.length} skill install(s); copied the files instead.`);
+      logger.tree(yellow("\u26A0") + `  Symlink creation failed for ${copiedFallbacks.length} skill install(s); copied the files instead.`, true);
     }
   }
   if (result.mcpServers.applied.length > 0) {
-    logger.subtitle("MCP");
+    logger.section("MCP Servers");
     const byAgent = new Map;
     for (const item of result.mcpServers.applied) {
       const list = byAgent.get(item.agent) || [];
       list.push(item.name);
       byAgent.set(item.agent, list);
     }
-    for (const [agent, servers] of byAgent) {
-      logger.info(`  ${agentManager12.getAgentById(agent)?.name || agent}: ${cyan(String(servers.length))} server(s) [${servers.join(", ")}]`);
+    const entries = [...byAgent.entries()];
+    for (let i = 0;i < entries.length; i++) {
+      const [agent, servers] = entries[i];
+      const agentName = agentManager12.getAgentById(agent)?.name || agent;
+      const coloredName = isClaudeAgent(agent) ? orange(agentName) : agentName;
+      logger.tree(`${coloredName}: ${cyan(String(servers.length))} server(s) [${servers.join(", ")}]`, i === entries.length - 1);
     }
   }
   if (result.nativePlugins.installed.length > 0) {
-    logger.subtitle("Native");
-    for (const nativePlugin of result.nativePlugins.installed) {
-      logger.info(`  ${agentManager12.getAgentById(nativePlugin.agent)?.name || nativePlugin.agent}: ${formatPathForDisplay(nativePlugin.installPath, projectPath)}`);
+    logger.section("Native Install");
+    for (let i = 0;i < result.nativePlugins.installed.length; i++) {
+      const nativePlugin = result.nativePlugins.installed[i];
+      const agentName = agentManager12.getAgentById(nativePlugin.agent)?.name || nativePlugin.agent;
+      const coloredName = isClaudeAgent(nativePlugin.agent) ? orange(agentName) : agentName;
+      logger.tree(`${coloredName}: ${dim(formatPathForDisplay(nativePlugin.installPath, projectPath))}`, i === result.nativePlugins.installed.length - 1);
     }
   }
 };
+var isClaudeAgent = function(agentId) {
+  return agentId === "claude" || agentId.startsWith("claude-");
+};
+var colorAgentLabel = function(agentIds, agentManager12) {
+  return agentIds.map((agentId) => {
+    const name = agentManager12.getAgentById(agentId)?.name || agentId;
+    return isClaudeAgent(agentId) ? orange(name) : name;
+  }).join(", ");
+};
 var buildGlobalPluginGroups = function(agentManager12, projectPath) {
   const dirToAgents = new Map;
   for (const agent of agentManager12.getAllAgents()) {
@@ -41779,6 +42471,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);