@orderful/droid 0.7.0 → 0.8.0

package/src/commands/tui.tsx

@@ -13,9 +13,6 @@ import {
   uninstallSkill,
   updateSkill,
   getSkillUpdateStatus,
-  isCommandInstalled,
-  installCommand,
-  uninstallCommand,
 } from '../lib/skills.js';
 import { getBundledAgents, getBundledAgentsDir, isAgentInstalled, installAgent, uninstallAgent, type AgentManifest } from '../lib/agents.js';
 import { configExists, loadConfig, saveConfig, loadSkillOverrides, saveSkillOverrides } from '../lib/config.js';
@@ -133,6 +130,56 @@ function getOutputOptions(): Array<{ label: string; value: OutputPreference }> {
   return options;
 }
 
+/**
+ * Check if an agent belongs to a skill bundle (whether installed or not)
+ * Returns the skill name if so, null otherwise
+ */
+function getAgentBundledSkill(agentName: string): string | null {
+  const skillsDir = getBundledSkillsDir();
+  if (!existsSync(skillsDir)) return null;
+
+  const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  for (const skillName of skillDirs) {
+    const agentDir = join(skillsDir, skillName, 'agents', agentName);
+    if (existsSync(agentDir)) {
+      return skillName;
+    }
+  }
+  return null;
+}
+
+/**
+ * Find the source path for an agent's AGENT.md
+ * Checks both standalone agents dir and skill-bundled agents
+ */
+function findAgentSourcePath(agentName: string): string | null {
+  // Check standalone agents first
+  const standalonePath = join(getBundledAgentsDir(), agentName, 'AGENT.md');
+  if (existsSync(standalonePath)) {
+    return standalonePath;
+  }
+
+  // Check skill-bundled agents
+  const skillsDir = getBundledSkillsDir();
+  if (existsSync(skillsDir)) {
+    const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+
+    for (const skillName of skillDirs) {
+      const skillAgentPath = join(skillsDir, skillName, 'agents', agentName, 'AGENT.md');
+      if (existsSync(skillAgentPath)) {
+        return skillAgentPath;
+      }
+    }
+  }
+
+  return null;
+}
+
 interface WelcomeScreenProps {
   onContinue: () => void;
   onUpdate: () => void;
@@ -461,13 +508,14 @@ function SetupScreen({ onComplete, onSkip, initialConfig }: SetupScreenProps) {
 
 function TabBar({ tabs, activeTab }: { tabs: { id: Tab; label: string }[]; activeTab: Tab }) {
   return (
-    <Box flexDirection="row">
+    <Box flexDirection="row" flexWrap="wrap">
       {tabs.map((tab) => (
         <Text
           key={tab.id}
           backgroundColor={tab.id === activeTab ? colors.primary : undefined}
           color={tab.id === activeTab ? '#ffffff' : colors.textMuted}
           bold={tab.id === activeTab}
+          wrap="truncate"
         >
           {' '}{tab.label}{' '}
         </Text>
@@ -648,20 +696,9 @@ function CommandDetails({
   }
 
   const skillInstalled = isSkillInstalled(command.skillName);
-  const installed = isCommandInstalled(command.name, command.skillName);
 
-  // If skill is installed, command comes with it - no standalone uninstall
-  const actions = skillInstalled
-    ? [{ id: 'view', label: 'View', variant: 'default' }]
-    : installed
-      ? [
-          { id: 'view', label: 'View', variant: 'default' },
-          { id: 'uninstall', label: 'Uninstall', variant: 'danger' },
-        ]
-      : [
-          { id: 'view', label: 'View', variant: 'default' },
-          { id: 'install', label: 'Install', variant: 'primary' },
-        ];
+  // Commands belong to skills - only show View, install via skill
+  const actions = [{ id: 'view', label: 'View', variant: 'default' }];
 
   return (
     <Box flexDirection="column" paddingLeft={2} flexGrow={1}>
@@ -670,8 +707,7 @@ function CommandDetails({
       <Box marginTop={1}>
         <Text color={colors.textDim}>
           from {command.skillName}
-          {skillInstalled && <Text color={colors.success}> · via skill</Text>}
-          {!skillInstalled && installed && <Text color={colors.success}> · installed</Text>}
+          {skillInstalled && <Text color={colors.success}> · installed</Text>}
         </Text>
       </Box>
 
@@ -747,18 +783,24 @@ function AgentDetails({
   }
 
   const installed = isAgentInstalled(agent.name);
+  const bundledSkill = getAgentBundledSkill(agent.name);
+  const skillInstalled = bundledSkill ? isSkillInstalled(bundledSkill) : false;
   const statusDisplay = agent.status === 'alpha' ? '[alpha]' : agent.status === 'beta' ? '[beta]' : '';
   const modeDisplay = agent.mode === 'primary' ? 'primary' : agent.mode === 'all' ? 'primary/subagent' : 'subagent';
 
-  const actions = installed
-    ? [
-        { id: 'view', label: 'View', variant: 'default' },
-        { id: 'uninstall', label: 'Uninstall', variant: 'danger' },
-      ]
-    : [
-        { id: 'view', label: 'View', variant: 'default' },
-        { id: 'install', label: 'Install', variant: 'primary' },
-      ];
+  // If agent belongs to a skill, only show View (install via skill)
+  // Otherwise show Install/Uninstall for standalone agents
+  const actions = bundledSkill
+    ? [{ id: 'view', label: 'View', variant: 'default' }]
+    : installed
+      ? [
+          { id: 'view', label: 'View', variant: 'default' },
+          { id: 'uninstall', label: 'Uninstall', variant: 'danger' },
+        ]
+      : [
+          { id: 'view', label: 'View', variant: 'default' },
+          { id: 'install', label: 'Install', variant: 'primary' },
+        ];
 
   return (
     <Box flexDirection="column" paddingLeft={2} flexGrow={1}>
@@ -769,7 +811,9 @@ function AgentDetails({
           v{agent.version}
           {statusDisplay && <Text> · {statusDisplay}</Text>}
           {' · '}{modeDisplay}
-          {installed && <Text color={colors.success}> · installed</Text>}
+          {bundledSkill && <Text color={colors.textMuted}> · from {bundledSkill}</Text>}
+          {skillInstalled && <Text color={colors.success}> · installed</Text>}
+          {!bundledSkill && installed && <Text color={colors.success}> · installed</Text>}
         </Text>
       </Box>
 
@@ -1017,6 +1061,8 @@ interface SkillConfigScreenProps {
   onCancel: () => void;
 }
 
+const MAX_VISIBLE_CONFIG_ITEMS = 4; // Each config item takes ~3 lines
+
 function SkillConfigScreen({ skill, onComplete, onCancel }: SkillConfigScreenProps) {
   const configSchema = skill.config_schema || {};
   const configKeys = Object.keys(configSchema);
@@ -1034,11 +1080,15 @@ function SkillConfigScreen({ skill, onComplete, onCancel }: SkillConfigScreenPro
   });
 
   const [selectedIndex, setSelectedIndex] = useState(0);
+  const [scrollOffset, setScrollOffset] = useState(0);
   const [editingField, setEditingField] = useState<string | null>(null);
   const [editValue, setEditValue] = useState('');
   const [editingSelect, setEditingSelect] = useState<string | null>(null);
   const [selectOptionIndex, setSelectOptionIndex] = useState(0);
 
+  // Total items = config keys + Save button
+  const totalItems = configKeys.length + 1;
+
   const handleSave = () => {
     saveSkillOverrides(skill.name, values);
     onComplete();
@@ -1090,11 +1140,25 @@ function SkillConfigScreen({ skill, onComplete, onCancel }: SkillConfigScreenPro
     }
 
     if (key.upArrow) {
-      setSelectedIndex((prev) => Math.max(0, prev - 1));
+      setSelectedIndex((prev) => {
+        const newIndex = Math.max(0, prev - 1);
+        // Scroll up if needed
+        if (newIndex < scrollOffset) {
+          setScrollOffset(newIndex);
+        }
+        return newIndex;
+      });
     }
     if (key.downArrow) {
       // +1 for the Save button at the end
-      setSelectedIndex((prev) => Math.min(configKeys.length, prev + 1));
+      setSelectedIndex((prev) => {
+        const newIndex = Math.min(totalItems - 1, prev + 1);
+        // Scroll down if needed
+        if (newIndex >= scrollOffset + MAX_VISIBLE_CONFIG_ITEMS) {
+          setScrollOffset(newIndex - MAX_VISIBLE_CONFIG_ITEMS + 1);
+        }
+        return newIndex;
+      });
     }
 
     if (key.return) {
@@ -1145,6 +1209,13 @@ function SkillConfigScreen({ skill, onComplete, onCancel }: SkillConfigScreenPro
     );
   }
 
+  // Calculate visible range
+  const visibleEndIndex = Math.min(scrollOffset + MAX_VISIBLE_CONFIG_ITEMS, totalItems);
+  const visibleConfigKeys = configKeys.slice(scrollOffset, Math.min(scrollOffset + MAX_VISIBLE_CONFIG_ITEMS, configKeys.length));
+  const showSaveButton = visibleEndIndex > configKeys.length || scrollOffset + MAX_VISIBLE_CONFIG_ITEMS > configKeys.length;
+  const showTopIndicator = scrollOffset > 0;
+  const showBottomIndicator = scrollOffset + MAX_VISIBLE_CONFIG_ITEMS < totalItems;
+
   return (
     <Box flexDirection="column" padding={1}>
       <Box marginBottom={1}>
@@ -1159,9 +1230,17 @@ function SkillConfigScreen({ skill, onComplete, onCancel }: SkillConfigScreenPro
       </Box>
 
       <Box flexDirection="column">
-        {configKeys.map((key, index) => {
+        {/* Scroll up indicator */}
+        {showTopIndicator && (
+          <Box marginBottom={1}>
+            <Text color={colors.textDim}>  ↑ {scrollOffset} more</Text>
+          </Box>
+        )}
+
+        {visibleConfigKeys.map((key) => {
+          const actualIndex = configKeys.indexOf(key);
           const option = configSchema[key];
-          const isSelected = selectedIndex === index;
+          const isSelected = selectedIndex === actualIndex;
           const isEditing = editingField === key;
 
           return (
@@ -1213,19 +1292,28 @@ function SkillConfigScreen({ skill, onComplete, onCancel }: SkillConfigScreenPro
           );
         })}
 
-        {/* Save button */}
-        <Box marginTop={1}>
-          <Text>
-            <Text color={colors.textDim}>{selectedIndex === configKeys.length ? '>' : ' '} </Text>
-            <Text
-              backgroundColor={selectedIndex === configKeys.length ? colors.primary : undefined}
-              color={selectedIndex === configKeys.length ? '#ffffff' : colors.textMuted}
-              bold={selectedIndex === configKeys.length}
-            >
-              {' '}Save{' '}
+        {/* Save button - show if in visible range */}
+        {showSaveButton && (
+          <Box marginTop={1}>
+            <Text>
+              <Text color={colors.textDim}>{selectedIndex === configKeys.length ? '>' : ' '} </Text>
+              <Text
+                backgroundColor={selectedIndex === configKeys.length ? colors.primary : undefined}
+                color={selectedIndex === configKeys.length ? '#ffffff' : colors.textMuted}
+                bold={selectedIndex === configKeys.length}
+              >
+                {' '}Save{' '}
+              </Text>
             </Text>
-          </Text>
-        </Box>
+          </Box>
+        )}
+
+        {/* Scroll down indicator */}
+        {showBottomIndicator && (
+          <Box marginTop={1}>
+            <Text color={colors.textDim}>  ↓ {totalItems - scrollOffset - MAX_VISIBLE_CONFIG_ITEMS} more</Text>
+          </Box>
+        )}
       </Box>
 
       <Box marginTop={1}>
@@ -1329,7 +1417,10 @@ function App() {
       }
       if (key.downArrow) {
         const maxIndex =
-          activeTab === 'skills' ? skills.length - 1 : activeTab === 'commands' ? commands.length - 1 : 0;
+          activeTab === 'skills' ? skills.length - 1
+          : activeTab === 'commands' ? commands.length - 1
+          : activeTab === 'agents' ? agents.length - 1
+          : 0;
         setSelectedIndex((prev) => {
           const newIndex = Math.min(maxIndex, prev + 1);
           // Scroll down if needed
@@ -1440,16 +1531,17 @@ function App() {
         const agent = agents[selectedIndex];
         if (agent) {
           const installed = isAgentInstalled(agent.name);
+          const bundledSkill = getAgentBundledSkill(agent.name);
           if (selectedAction === 0) {
             // View
-            const agentMdPath = join(getBundledAgentsDir(), agent.name, 'AGENT.md');
-            if (existsSync(agentMdPath)) {
+            const agentMdPath = findAgentSourcePath(agent.name);
+            if (agentMdPath) {
               const content = readFileSync(agentMdPath, 'utf-8');
               setReadmeContent({ title: `${agent.name}/AGENT.md`, content });
               setView('readme');
             }
-          } else if (installed && selectedAction === 1) {
-            // Uninstall
+          } else if (!bundledSkill && installed && selectedAction === 1) {
+            // Uninstall (only for standalone agents)
             const result = uninstallAgent(agent.name);
             setMessage({
               text: result.success ? `✓ Uninstalled ${agent.name}` : `✗ ${result.message}`,
@@ -1459,8 +1551,8 @@ function App() {
               setView('menu');
               setSelectedAction(0);
             }
-          } else if (!installed && selectedAction === 1) {
-            // Install
+          } else if (!bundledSkill && !installed && selectedAction === 1) {
+            // Install (only for standalone agents)
             const result = installAgent(agent.name);
             setMessage({
               text: result.success ? `✓ ${result.message}` : `✗ ${result.message}`,
@@ -1476,42 +1568,17 @@ function App() {
       if (key.return && activeTab === 'commands') {
         const command = commands[selectedIndex];
         if (command) {
-          const installed = isCommandInstalled(command.name, command.skillName);
           // Command file: extract part after skill name (e.g., "comments check" → "check.md")
           const cmdPart = command.name.startsWith(command.skillName + ' ')
             ? command.name.slice(command.skillName.length + 1)
             : command.name;
           const commandMdPath = join(getBundledSkillsDir(), command.skillName, 'commands', `${cmdPart}.md`);
 
-          if (selectedAction === 0) {
-            // View
-            if (existsSync(commandMdPath)) {
-              const content = readFileSync(commandMdPath, 'utf-8');
-              setReadmeContent({ title: `/${command.name}`, content });
-              setView('readme');
-            }
-          } else if (installed && selectedAction === 1) {
-            // Uninstall
-            const result = uninstallCommand(command.name, command.skillName);
-            setMessage({
-              text: result.success ? `✓ ${result.message}` : `✗ ${result.message}`,
-              type: result.success ? 'success' : 'error',
-            });
-            if (result.success) {
-              setView('menu');
-              setSelectedAction(0);
-            }
-          } else if (!installed && selectedAction === 1) {
-            // Install
-            const result = installCommand(command.name, command.skillName);
-            setMessage({
-              text: result.success ? `✓ ${result.message}` : `✗ ${result.message}`,
-              type: result.success ? 'success' : 'error',
-            });
-            if (result.success) {
-              setView('menu');
-              setSelectedAction(0);
-            }
+          // Only View action available - commands install via skills
+          if (selectedAction === 0 && existsSync(commandMdPath)) {
+            const content = readFileSync(commandMdPath, 'utf-8');
+            setReadmeContent({ title: `/${command.name}`, content });
+            setView('readme');
           }
         }
       }

package/src/lib/agents.ts

@@ -3,10 +3,23 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
 import YAML from 'yaml';
+import { loadConfig } from './config.js';
+import { AITool } from './types.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const BUNDLED_AGENTS_DIR = join(__dirname, '../agents');
-const INSTALLED_AGENTS_DIR = join(homedir(), '.claude', 'agents');
+
+/**
+ * Get the installation path for agents based on AI tool
+ */
+export function getAgentsInstallPath(aiTool: AITool): string {
+  switch (aiTool) {
+    case AITool.ClaudeCode:
+      return join(homedir(), '.claude', 'agents');
+    case AITool.OpenCode:
+      return join(homedir(), '.config', 'opencode', 'agent');
+  }
+}
 
 /**
  * Agent manifest structure
@@ -17,6 +30,8 @@ export interface AgentManifest {
   version: string;
   status?: 'alpha' | 'beta' | 'stable';
   mode?: 'primary' | 'subagent' | 'all'; // How the agent is used
+  model?: string; // Model to use (e.g., 'sonnet', 'opus', 'haiku')
+  color?: string; // Display color (e.g., 'purple', 'blue', 'green')
   tools?: string[]; // Allowed tools for this agent
   triggers?: string[];
   persona?: string;
@@ -48,23 +63,49 @@ export function loadAgentManifest(agentDir: string): AgentManifest | null {
 }
 
 /**
- * Get all bundled agents
+ * Get all bundled agents (standalone + skill-bundled)
  */
 export function getBundledAgents(): AgentManifest[] {
-  if (!existsSync(BUNDLED_AGENTS_DIR)) {
-    return [];
+  const agents: AgentManifest[] = [];
+  const seenNames = new Set<string>();
+
+  // Get standalone agents from src/agents/
+  if (existsSync(BUNDLED_AGENTS_DIR)) {
+    const agentDirs = readdirSync(BUNDLED_AGENTS_DIR, { withFileTypes: true })
+      .filter((dirent) => dirent.isDirectory())
+      .map((dirent) => dirent.name);
+
+    for (const agentDir of agentDirs) {
+      const manifest = loadAgentManifest(join(BUNDLED_AGENTS_DIR, agentDir));
+      if (manifest && !seenNames.has(manifest.name)) {
+        agents.push(manifest);
+        seenNames.add(manifest.name);
+      }
+    }
   }
 
-  const agentDirs = readdirSync(BUNDLED_AGENTS_DIR, { withFileTypes: true })
-    .filter((dirent) => dirent.isDirectory())
-    .map((dirent) => dirent.name);
+  // Get skill-bundled agents from src/skills/*/agents/
+  const skillsDir = join(__dirname, '../skills');
+  if (existsSync(skillsDir)) {
+    const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
+      .filter((dirent) => dirent.isDirectory())
+      .map((dirent) => dirent.name);
 
-  const agents: AgentManifest[] = [];
+    for (const skillName of skillDirs) {
+      const skillAgentsDir = join(skillsDir, skillName, 'agents');
+      if (!existsSync(skillAgentsDir)) continue;
+
+      const agentDirs = readdirSync(skillAgentsDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
 
-  for (const agentDir of agentDirs) {
-    const manifest = loadAgentManifest(join(BUNDLED_AGENTS_DIR, agentDir));
-    if (manifest) {
-      agents.push(manifest);
+      for (const agentDir of agentDirs) {
+        const manifest = loadAgentManifest(join(skillAgentsDir, agentDir));
+        if (manifest && !seenNames.has(manifest.name)) {
+          agents.push(manifest);
+          seenNames.add(manifest.name);
+        }
+      }
     }
   }
 
@@ -87,26 +128,74 @@ export function getAgentStatusDisplay(status?: string): string {
 }
 
 /**
- * Get installed agents directory
+ * Get installed agents directory for the configured AI tool
  */
 export function getInstalledAgentsDir(): string {
-  return INSTALLED_AGENTS_DIR;
+  const config = loadConfig();
+  return getAgentsInstallPath(config.ai_tool);
 }
 
 /**
  * Check if an agent is installed
  */
 export function isAgentInstalled(agentName: string): boolean {
-  const agentPath = join(INSTALLED_AGENTS_DIR, `${agentName}.md`);
+  const config = loadConfig();
+  const agentsDir = getAgentsInstallPath(config.ai_tool);
+  const agentPath = join(agentsDir, `${agentName}.md`);
   return existsSync(agentPath);
 }
 
 /**
- * Install an agent to ~/.claude/agents/
- * Combines AGENT.yaml metadata with AGENT.md content into a single .md file
+ * Generate Claude Code agent frontmatter
  */
-export function installAgent(agentName: string): { success: boolean; message: string } {
-  const agentDir = join(BUNDLED_AGENTS_DIR, agentName);
+function generateClaudeCodeAgent(manifest: AgentManifest, agentContent: string): string {
+  const lines = [
+    '---',
+    `name: ${manifest.name}`,
+    `description: ${manifest.description}`,
+  ];
+
+  if (manifest.tools && manifest.tools.length > 0) {
+    lines.push(`tools: ${manifest.tools.join(', ')}`);
+  }
+  if (manifest.color) {
+    lines.push(`color: ${manifest.color}`);
+  }
+
+  lines.push('---', '', agentContent.trim(), '');
+  return lines.join('\n');
+}
+
+/**
+ * Generate OpenCode agent frontmatter
+ * OpenCode uses a different format with explicit tool permissions
+ */
+function generateOpenCodeAgent(manifest: AgentManifest, agentContent: string): string {
+  const lines = [
+    '---',
+    `description: ${manifest.description}`,
+    `mode: ${manifest.mode || 'subagent'}`,
+  ];
+
+  // OpenCode uses explicit tool permissions
+  if (manifest.tools && manifest.tools.length > 0) {
+    lines.push('tools:');
+    for (const tool of manifest.tools) {
+      const toolName = tool.toLowerCase();
+      lines.push(`  ${toolName}: true`);
+    }
+  }
+
+  lines.push('---', '', agentContent.trim(), '');
+  return lines.join('\n');
+}
+
+/**
+ * Install an agent from a specific path
+ * Generates the appropriate format based on the configured AI tool
+ */
+export function installAgentFromPath(agentDir: string, agentName: string): { success: boolean; message: string } {
+  const config = loadConfig();
   const manifestPath = join(agentDir, 'AGENT.yaml');
   const contentPath = join(agentDir, 'AGENT.md');
 
@@ -132,46 +221,47 @@ export function installAgent(agentName: string): { success: boolean; message: st
       agentContent = manifest.persona;
     }
 
-    // Build frontmatter for Claude Code agent format
-    const frontmatter: Record<string, unknown> = {
-      name: manifest.name,
-      description: manifest.description,
-    };
-
-    // Add tools if specified
-    if (manifest.tools && manifest.tools.length > 0) {
-      frontmatter.tools = manifest.tools.join(', ');
-    }
-
-    // Generate the installed agent file
-    const installedContent = `---
-name: ${frontmatter.name}
-description: ${frontmatter.description}${frontmatter.tools ? `\ntools: ${frontmatter.tools}` : ''}
----
-
-${agentContent.trim()}
-`;
+    // Generate format based on AI tool
+    const installedContent = config.ai_tool === AITool.ClaudeCode
+      ? generateClaudeCodeAgent(manifest, agentContent)
+      : generateOpenCodeAgent(manifest, agentContent);
 
     // Ensure agents directory exists
-    if (!existsSync(INSTALLED_AGENTS_DIR)) {
-      mkdirSync(INSTALLED_AGENTS_DIR, { recursive: true });
+    const agentsDir = getAgentsInstallPath(config.ai_tool);
+    if (!existsSync(agentsDir)) {
+      mkdirSync(agentsDir, { recursive: true });
     }
 
     // Write the agent file
-    const outputPath = join(INSTALLED_AGENTS_DIR, `${agentName}.md`);
+    const outputPath = join(agentsDir, `${agentName}.md`);
     writeFileSync(outputPath, installedContent);
 
-    return { success: true, message: `Installed ${agentName} to ~/.claude/agents/` };
+    const targetDir = config.ai_tool === AITool.ClaudeCode
+      ? '~/.claude/agents/'
+      : '~/.config/opencode/agent/';
+
+    return { success: true, message: `Installed ${agentName} to ${targetDir}` };
   } catch (error) {
     return { success: false, message: `Failed to install agent: ${error}` };
   }
 }
 
 /**
- * Uninstall an agent from ~/.claude/agents/
+ * Install an agent from the bundled agents directory
+ * Combines AGENT.yaml metadata with AGENT.md content into a single .md file
+ */
+export function installAgent(agentName: string): { success: boolean; message: string } {
+  const agentDir = join(BUNDLED_AGENTS_DIR, agentName);
+  return installAgentFromPath(agentDir, agentName);
+}
+
+/**
+ * Uninstall an agent from the agents directory
  */
 export function uninstallAgent(agentName: string): { success: boolean; message: string } {
-  const agentPath = join(INSTALLED_AGENTS_DIR, `${agentName}.md`);
+  const config = loadConfig();
+  const agentsDir = getAgentsInstallPath(config.ai_tool);
+  const agentPath = join(agentsDir, `${agentName}.md`);
 
   if (!existsSync(agentPath)) {
     return { success: false, message: `Agent not installed: ${agentName}` };