agentinit 1.13.3 → 1.14.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();
@@ -16708,7 +16861,7 @@ __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 {promises as fs20} from "fs";
 import {homedir as homedir3} from "os";
 
 class MarketplacePluginNotFoundError extends Error {
@@ -16743,7 +16896,7 @@ class PluginManager {
   }
   async cleanupLoadedPluginContext(context) {
     if (context?.tempDir) {
-      await fs18.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
+      await fs20.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -16814,6 +16967,12 @@ class PluginManager {
     }
     return `https://github.com/${source.owner}/${source.repo}`;
   }
+  getGitHubFallbackTrust(source) {
+    if (source.owner === "openai" && source.repo === "codex-plugin-cc") {
+      return "verified";
+    }
+    return "unverified";
+  }
   async resolvePreparedPluginDir(pluginDir, source) {
     const claudeMarketplaceManifestPath = join3(pluginDir, ".claude-plugin", "marketplace.json");
     if (!await fileExists(claudeMarketplaceManifestPath)) {
@@ -16894,12 +17053,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,
@@ -17070,10 +17230,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 fs20.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 fs20.mkdir(dirname2(nativeTarget.installPath), { recursive: true });
+    await fs20.cp(pluginDir, nativeTarget.installPath, { recursive: true, dereference: true });
     const now = new Date().toISOString();
     claudeInstalled.plugins[nativeTarget.pluginKey] = [{
       scope: "user",
@@ -17121,7 +17281,7 @@ class PluginManager {
       claudeSettings.enabledPlugins = remainingEnabledPlugins;
       await this.saveClaudeSettings(claudeSettings);
     }
-    await fs18.rm(component.installPath, { recursive: true, force: true }).catch(() => {
+    await fs20.rm(component.installPath, { recursive: true, force: true }).catch(() => {
     });
     return true;
   }
@@ -17197,7 +17357,7 @@ class PluginManager {
     const cacheMetaPath = join3(cacheDir, ".agentinit-cache-meta.json");
     if (await fileExists(cacheMetaPath)) {
       try {
-        const meta = JSON.parse(await fs18.readFile(cacheMetaPath, "utf8"));
+        const meta = JSON.parse(await fs20.readFile(cacheMetaPath, "utf8"));
         const age = Date.now() - (meta.fetchedAt || 0);
         if (age < registry.cacheTtlMs) {
           return cacheDir;
@@ -17212,22 +17372,22 @@ class PluginManager {
       try {
         await exec("git", ["pull", "--ff-only"], { cwd: cacheDir, timeout: 30000 });
       } catch {
-        await fs18.rm(cacheDir, { recursive: true, force: true });
+        await fs20.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 fs20.mkdir(cacheDir, { recursive: true });
+    await fs20.writeFile(cacheMetaPath, JSON.stringify({ fetchedAt: Date.now() }));
     return cacheDir;
   }
   async cloneMarketplace(repoUrl, dest) {
-    await fs18.mkdir(dest, { recursive: true });
+    await fs20.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 fs20.rm(dest, { recursive: true, force: true }).catch(() => {
     });
     await exec("git", ["clone", "--depth", "1", repoUrl, dest], { timeout: 60000 });
   }
@@ -17272,7 +17432,7 @@ class PluginManager {
         let version = "0.0.0";
         if (await fileExists(manifestPath)) {
           try {
-            const manifest = JSON.parse(await fs18.readFile(manifestPath, "utf8"));
+            const manifest = JSON.parse(await fs20.readFile(manifestPath, "utf8"));
             name = manifest.name || entry;
             description = manifest.description || "";
             version = manifest.version || "0.0.0";
@@ -17282,7 +17442,7 @@ class PluginManager {
           const skillMdPath = join3(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 fs20.readFile(skillMdPath, "utf8"));
               if (parsed.data.name)
                 name = parsed.data.name;
               if (parsed.data.description)
@@ -17293,7 +17453,7 @@ class PluginManager {
             const mcpPath = join3(entryPath, ".mcp.json");
             if (await fileExists(mcpPath)) {
               try {
-                const mcpConfig = JSON.parse(await fs18.readFile(mcpPath, "utf8"));
+                const mcpConfig = JSON.parse(await fs20.readFile(mcpPath, "utf8"));
                 const serverNames = Object.keys(mcpConfig.mcpServers || mcpConfig);
                 if (serverNames.length > 0) {
                   description = `MCP server(s): ${serverNames.join(", ")}`;
@@ -17748,7 +17908,7 @@ ${body.trim()}
       }
       if (!removedSkillPaths.has(skill.path)) {
         try {
-          await fs18.rm(skill.path, { recursive: true, force: true });
+          await fs20.rm(skill.path, { recursive: true, force: true });
           removedSkillPaths.add(skill.path);
         } catch {
           details.push(`Could not remove skill path: ${skill.path}`);
@@ -17757,7 +17917,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 fs20.rm(skill.canonicalPath, { recursive: true, force: true });
           removedCanonicalPaths.add(skill.canonicalPath);
         } catch {
           details.push(`Could not remove canonical skill path: ${skill.canonicalPath}`);
@@ -17880,7 +18040,7 @@ var init_pluginManager = __esm(() => {
 
 // dist/core/skillsManager.js
 import {resolve as resolve8, join as join4, relative as relative3} from "path";
-import {promises as fs20} from "fs";
+import {promises as fs22} from "fs";
 import {homedir as homedir4, tmpdir} from "os";
 import {execFile} from "child_process";
 import {promisify} from "util";
@@ -18022,14 +18182,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 fs22.mkdtemp(join4(tmpdir(), "agentinit-skills-"));
+    await fs22.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 fs22.rm(tempDir, { recursive: true, force: true }).catch(() => {
       });
       throw new Error(`Failed to clone ${url}: ${error.message}`);
     }
@@ -18123,7 +18283,7 @@ class SkillsManager {
       return { skills, warnings };
     } finally {
       if (tempDir) {
-        await fs20.rm(tempDir, { recursive: true, force: true }).catch(() => {
+        await fs22.rm(tempDir, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -18144,26 +18304,26 @@ 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 fs22.mkdir(resolve8(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs20.rm(destPath, { recursive: true, force: true });
+      await fs22.rm(destPath, { recursive: true, force: true });
     }
     if (copy) {
       await this.copyDir(skillPath, destPath);
     } else {
-      await fs20.symlink(skillPath, destPath, "dir");
+      await fs22.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 fs22.mkdir(resolve8(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs20.rm(destPath, { recursive: true, force: true });
+      await fs22.rm(destPath, { recursive: true, force: true });
     }
-    await fs20.mkdir(destPath, { recursive: true });
-    await fs20.writeFile(join4(destPath, "SKILL.md"), skillContent, "utf8");
+    await fs22.mkdir(destPath, { recursive: true });
+    await fs22.writeFile(join4(destPath, "SKILL.md"), skillContent, "utf8");
     return destPath;
   }
   getCanonicalSkillsDir(projectPath, global3 = false) {
@@ -18241,7 +18401,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 fs22.writeFile(join4(canonicalPath, "SKILL.md"), skillContent, "utf8");
     if (plan.path === canonicalPath) {
       return plan;
     }
@@ -18278,16 +18438,16 @@ class SkillsManager {
     return this.resolveInstallPath(targetDir, this.normalizeSkillName(skillName));
   }
   async cleanAndCreateDirectory(path) {
-    await fs20.rm(path, { recursive: true, force: true }).catch(() => {
+    await fs22.rm(path, { recursive: true, force: true }).catch(() => {
     });
-    await fs20.mkdir(path, { recursive: true });
+    await fs22.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 fs22.cp(src, dest, { recursive: true, dereference: true });
   }
   async addFromSource(source, projectPath, options2 = {}) {
     const discovered = await this.discoverFromSource(source, projectPath, {
@@ -18376,7 +18536,7 @@ class SkillsManager {
           let isSymlink = false;
           let canonicalPath;
           try {
-            const stat = await fs20.lstat(entryPath);
+            const stat = await fs22.lstat(entryPath);
             isSymlink = stat.isSymbolicLink();
             const canonicalBase = this.getCanonicalSkillsDir(projectPath, scope === "global");
             const [resolvedEntryPath, resolvedCanonicalBase] = await Promise.all([
@@ -18442,7 +18602,7 @@ class SkillsManager {
       }
       if (!removedPaths.has(entry.path)) {
         try {
-          await fs20.rm(entry.path, { recursive: true, force: true });
+          await fs22.rm(entry.path, { recursive: true, force: true });
           removedPaths.add(entry.path);
         } catch {
           skipped.push({
@@ -18455,7 +18615,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 fs22.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
           });
           removedCanonicalPaths.add(entry.canonicalPath);
         }
@@ -19869,7 +20029,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 +20047,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 +24851,27 @@ var require_windows = __commonJS((exports, module) => {
     return checkPathExt(path, options2);
   };
   var isexe = function(path, options2, cb) {
-    fs27.stat(path, function(er, stat) {
+    fs29.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(fs29.statSync(path), path, options2);
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs27 = __require("fs");
+  var fs29 = __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) {
+    fs29.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(fs29.statSync(path), options2);
   };
   var checkStat = function(stat, options2) {
     return stat.isFile() && checkMode(stat, options2);
@@ -24731,7 +24891,7 @@ var require_mode = __commonJS((exports, module) => {
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs27 = __require("fs");
+  var fs29 = __require("fs");
 });
 
 // node_modules/isexe/index.js
@@ -24776,7 +24936,7 @@ var require_isexe = __commonJS((exports, module) => {
       }
     }
   };
-  var fs27 = __require("fs");
+  var fs29 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -24983,14 +25143,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 = fs29.openSync(command, "r");
+      fs29.readSync(fd, buffer, 0, size, 0);
+      fs29.closeSync(fd);
     } catch (e) {
     }
     return shebangCommand(buffer.toString());
   };
-  var fs27 = __require("fs");
+  var fs29 = __require("fs");
   var shebangCommand = require_shebang_command();
   module.exports = readShebang;
 });
@@ -25142,7 +25302,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 +26653,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 +26701,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 +26724,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 +26756,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 +26768,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 +26791,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 +26841,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 +26887,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 +26919,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 +26951,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 +27010,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 +27025,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 +27042,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 +27325,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 +27403,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 +27416,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 +27484,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 fs24} from "fs";
 import {resolve as resolve9} from "path";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -30002,7 +30252,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 fs24.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 +30283,7 @@ class Propagator {
     if (!options2.dryRun) {
       if (generatedFile.kind === "file") {
         if (existingStats?.isSymbolicLink()) {
-          await fs22.rm(generatedFile.path, { force: true }).catch(() => {
+          await fs24.rm(generatedFile.path, { force: true }).catch(() => {
           });
         }
         await writeFile(generatedFile.path, generatedFile.content || "");
@@ -30210,14 +30460,14 @@ ${content}
 
 // dist/core/managedState.js
 init_fs();
-import {promises as fs24} from "fs";
+import {promises as fs26} from "fs";
 import {dirname as dirname3, join as join5, 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 fs26.lstat(targetPath);
     if (stat.isSymbolicLink()) {
       return "symlink";
     }
@@ -30227,20 +30477,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 fs26.mkdir(dest, { recursive: true });
+  const entries = await fs26.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = join5(src, entry.name);
     const destPath = join5(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 fs26.readlink(srcPath);
+      await fs26.mkdir(dirname3(destPath), { recursive: true });
+      await fs26.symlink(target, destPath);
     } else {
-      await fs24.mkdir(dirname3(destPath), { recursive: true });
-      await fs24.copyFile(srcPath, destPath);
+      await fs26.mkdir(dirname3(destPath), { recursive: true });
+      await fs26.copyFile(srcPath, destPath);
     }
   }
 }
@@ -30249,14 +30499,14 @@ async function copyPath(src, dest) {
   if (!type2) {
     return;
   }
-  await fs24.mkdir(dirname3(dest), { recursive: true });
+  await fs26.mkdir(dirname3(dest), { recursive: true });
   if (type2 === "symlink") {
-    const target = await fs24.readlink(src);
-    await fs24.symlink(target, dest);
+    const target = await fs26.readlink(src);
+    await fs26.symlink(target, dest);
   } else if (type2 === "directory") {
     await copyDirectory(src, dest);
   } else {
-    await fs24.copyFile(src, dest);
+    await fs26.copyFile(src, dest);
   }
 }
 var MANAGED_STATE_FILE = "managed-state.json";
@@ -30274,7 +30524,7 @@ class ManagedStateStore {
     const statePath = join5(agentInitDir, MANAGED_STATE_FILE);
     const emptyState = { version: 1, entries: [] };
     try {
-      const raw = await fs24.readFile(statePath, "utf8");
+      const raw = await fs26.readFile(statePath, "utf8");
       const parsed = JSON.parse(raw);
       if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) {
         return new ManagedStateStore(projectPath, emptyState);
@@ -30313,7 +30563,7 @@ class ManagedStateStore {
     }
     if (type2 === "symlink") {
       try {
-        const backupLinkTarget = await fs24.readlink(targetPath);
+        const backupLinkTarget = await fs26.readlink(targetPath);
         return { backupLinkTarget };
       } catch {
         return {};
@@ -30355,20 +30605,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 fs26.mkdir(this.agentInitDir, { recursive: true });
+    await fs26.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
   }
   async revertAll(options2 = {}) {
     const summary = {
@@ -30383,29 +30633,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 fs26.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
-          await fs24.mkdir(dirname3(absolutePath), { recursive: true });
-          await fs24.symlink(backupLinkTarget, absolutePath);
+          await fs26.mkdir(dirname3(absolutePath), { recursive: true });
+          await fs26.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 fs26.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 fs26.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 fs26.rm(backupPath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.backupsRemoved++;
@@ -30413,16 +30663,16 @@ class ManagedStateStore {
     }
     if (!options2.dryRun) {
       this.state.entries.length = 0;
-      await fs24.rm(this.stateFilePath, { force: true }).catch(() => {
+      await fs26.rm(this.stateFilePath, { force: true }).catch(() => {
       });
       if (!options2.keepBackups) {
-        await fs24.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
+        await fs26.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
         });
       }
       try {
-        const remainingEntries = await fs24.readdir(this.agentInitDir);
+        const remainingEntries = await fs26.readdir(this.agentInitDir);
         if (remainingEntries.length === 0) {
-          await fs24.rm(this.agentInitDir, { recursive: true, force: true });
+          await fs26.rm(this.agentInitDir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -30436,7 +30686,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");
   }
@@ -38960,7 +39210,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 +39260,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,7 +39292,7 @@ class MCPVerifier {
 }
 
 // dist/core/gitignoreManager.js
-import {promises as fs27} from "fs";
+import {promises as fs29} from "fs";
 import {dirname as dirname6, join as join7} from "path";
 var normalizeIgnorePath = function(projectPath, value) {
   const relative6 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
@@ -39089,13 +39339,13 @@ var updateManagedBlock = function(existingContent, entries) {
   }
   return content;
 };
-async function updateManagedIgnoreFile(projectPath, paths2, options2 = {}) {
+async function updateManagedIgnoreFile(projectPath, paths5, options2 = {}) {
   const ignoreFile = options2.local ? join7(".git", "info", "exclude") : ".gitignore";
   const ignoreFilePath = join7(projectPath, ignoreFile);
   if (options2.local) {
     const gitDir = join7(projectPath, ".git");
     try {
-      const stat = await fs27.stat(gitDir);
+      const stat = await fs29.stat(gitDir);
       if (!stat.isDirectory()) {
         throw new Error;
       }
@@ -39103,16 +39353,16 @@ 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 fs29.readFile(ignoreFilePath, "utf8");
   } catch {
     existingContent = "";
   }
   const updatedContent = updateManagedBlock(existingContent, normalizedPaths);
-  await fs27.mkdir(dirname6(ignoreFilePath), { recursive: true });
-  await fs27.writeFile(ignoreFilePath, updatedContent, "utf8");
+  await fs29.mkdir(dirname6(ignoreFilePath), { recursive: true });
+  await fs29.writeFile(ignoreFilePath, updatedContent, "utf8");
   return ignoreFilePath;
 }
 async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
@@ -39120,7 +39370,7 @@ async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
   const ignoreFilePath = join7(projectPath, ignoreFile);
   let content;
   try {
-    content = await fs27.readFile(ignoreFilePath, "utf8");
+    content = await fs29.readFile(ignoreFilePath, "utf8");
   } catch {
     return false;
   }
@@ -39136,13 +39386,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 fs29.rm(ignoreFilePath, { force: true }).catch(() => {
     });
   } else {
     if (!nextContent.endsWith("\n")) {
       nextContent += "\n";
     }
-    await fs27.writeFile(ignoreFilePath, nextContent, "utf8");
+    await fs29.writeFile(ignoreFilePath, nextContent, "utf8");
   }
   return true;
 }
@@ -39276,7 +39526,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 +39650,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 +40055,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 +40259,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");
   }
@@ -40060,8 +40310,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 +40361,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 +40401,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.");
@@ -41073,7 +41323,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 +41451,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 +41491,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...>");
@@ -41300,13 +41550,28 @@ function registerRulesCommand(program2) {
 // dist/commands/plugins.js
 var import_prompts3 = __toESM(require_prompts3(), 1);
 import {dirname as dirname8, relative as relative8} from "path";
+
+// dist/utils/colors.js
+var colorsEnabled = function() {
+  const env2 = process.env || {};
+  const isTTY2 = !!process.stdout?.isTTY;
+  return !env2.NODE_DISABLE_COLORS && env2.NO_COLOR == null && env2.TERM !== "dumb" && (env2.FORCE_COLOR != null && env2.FORCE_COLOR !== "0" || isTTY2);
+};
+function orange(text) {
+  if (!colorsEnabled()) {
+    return text;
+  }
+  return `\x1B[38;5;208m${text}\x1B[39m`;
+}
+
+// dist/commands/plugins.js
 init_pluginManager();
 init_agentManager();
 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,7 +41687,7 @@ 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) {
       logger.info(`Please specify a marketplace with --from <marketplace>. Available: ${marketplaceHelp}`);
@@ -41463,7 +41728,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 +41764,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 +41814,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 +41883,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 +41957,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()) {
@@ -41696,6 +42028,25 @@ var buildGlobalPluginGroups = function(agentManager12, projectPath) {
     compatibleAgentNames: []
   }));
 };
+var getPluginGroupDescription = function(group, preview, projectPath) {
+  const portableSummary = getPortableComponentSummary(preview);
+  if (!preview.nativePreview) {
+    return portableSummary;
+  }
+  const containsClaudeCode = group.agents.some((agent) => agent.id === "claude");
+  if (!containsClaudeCode) {
+    return `${portableSummary}. Skills will be installed here, but Claude-specific components will not be fully available for these agents.`;
+  }
+  const otherAgents = group.agents.filter((agent) => agent.id !== "claude").map((agent) => agent.name);
+  const installPath = formatPathForDisplay(preview.nativePreview.installPath, projectPath);
+  if (otherAgents.length === 0) {
+    return `${portableSummary}. Full plugin support is available in Claude Code; the native plugin installs at ${installPath}.`;
+  }
+  const otherAgentsLabel = otherAgents.join(", ");
+  const shareVerb = otherAgents.length === 1 ? "shares" : "share";
+  const receiveVerb = otherAgents.length === 1 ? "receives" : "receive";
+  return `${portableSummary}. Full plugin support is available in Claude Code; the native plugin installs at ${installPath}. ${otherAgentsLabel} ${shareVerb} this skills directory but only ${receiveVerb} the installed skills.`;
+};
 async function interactiveAgentSelect(pluginManager2, agentManager12, projectPath, global3, preview) {
   let installGlobal = !!global3;
   let groups = installGlobal ? buildGlobalPluginGroups(agentManager12, projectPath) : (await pluginManager2.groupAgentsBySkillsDir(projectPath, false)).map((group) => ({
@@ -41733,16 +42084,14 @@ async function interactiveAgentSelect(pluginManager2, agentManager12, projectPat
   const response = await import_prompts3.default({
     type: "multiselect",
     name: "groups",
-    message: installGlobal ? "Select target global agent skills directories:" : "Select target agent skills directories:",
+    message: installGlobal ? "Select which global agents should receive this plugin:" : "Select which agents should receive this plugin:",
     instructions: false,
     min: 1,
     choices: groups.map((group) => {
-      const containsClaude = group.agents.some((agent) => agent.id === "claude");
       const compatible = group.compatibleAgentNames.length > 0 ? dim(` (also compatible: ${group.compatibleAgentNames.join(", ")})`) : "";
-      const description = preview.nativePreview ? containsClaude ? `${getPortableComponentSummary(preview)}. Also installs the Claude native plugin at ${formatPathForDisplay(preview.nativePreview.installPath, projectPath)}.` : `${getPortableComponentSummary(preview)} only. Claude-only components remain unavailable for these agents.` : getPortableComponentSummary(preview);
       return {
         title: `${group.displayDir} -> ${getAgentLabel(group.agents.map((agent) => agent.id), agentManager12)}${compatible}`,
-        description,
+        description: getPluginGroupDescription(group, preview, projectPath),
         value: group.agents.map((agent) => agent.id),
         selected: true
       };