agentgui 1.0.615 → 1.0.617

package/lib/tool-manager.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import os from 'os';
 import fs from 'fs';
 import path from 'path';
@@ -10,10 +10,10 @@ const TOOLS = [
   { id: 'cli-gemini', name: 'Gemini CLI', pkg: '@google/gemini-cli', category: 'cli' },
   { id: 'cli-kilo', name: 'Kilo Code', pkg: '@kilocode/cli', category: 'cli' },
   { id: 'cli-codex', name: 'Codex CLI', pkg: '@openai/codex', category: 'cli' },
-  { id: 'gm-cc', name: 'GM Claude', pkg: 'gm-cc', pluginId: 'gm-cc', category: 'plugin' },
-  { id: 'gm-oc', name: 'GM OpenCode', pkg: 'gm-oc', pluginId: 'gm-oc', category: 'plugin' },
-  { id: 'gm-gc', name: 'GM Gemini', pkg: 'gm-gc', pluginId: 'gm', category: 'plugin' },
-  { id: 'gm-kilo', name: 'GM Kilo', pkg: 'gm-kilo', pluginId: 'gm-kilo', category: 'plugin' },
+  { id: 'gm-cc', name: 'GM Claude', pkg: 'gm-cc', pluginId: 'gm-cc', category: 'plugin', frameWork: 'claude' },
+  { id: 'gm-oc', name: 'GM OpenCode', pkg: 'gm-oc', pluginId: 'gm', category: 'plugin', frameWork: 'opencode' },
+  { id: 'gm-gc', name: 'GM Gemini', pkg: 'gm-gc', pluginId: 'gm', category: 'plugin', frameWork: 'gemini' },
+  { id: 'gm-kilo', name: 'GM Kilo', pkg: 'gm-kilo', pluginId: 'gm', category: 'plugin', frameWork: 'kilo' },
 ];
 
 const statusCache = new Map();
@@ -22,74 +22,115 @@ const versionCache = new Map();
 
 const getTool = (id) => TOOLS.find(t => t.id === id);
 
-const getInstalledVersion = (pkg, pluginId = null) => {
+const getInstalledVersion = (pkg, pluginId = null, frameWork = null) => {
   try {
     const homeDir = os.homedir();
-    const tool = pluginId ? TOOLS.find(t => t.pkg === pkg) : null;
-    const actualPluginId = pluginId || (tool?.pluginId) || pkg;
+    const tool = TOOLS.find(t => t.pkg === pkg);
+    const actualPluginId = pluginId || tool?.pluginId || pkg;
+    const actualFrameWork = frameWork || tool?.frameWork;
 
     // Check Claude Code plugins using correct pluginId
-    const claudePath = path.join(homeDir, '.claude', 'plugins', actualPluginId, 'plugin.json');
-    if (fs.existsSync(claudePath)) {
-      try {
-        const pluginJson = JSON.parse(fs.readFileSync(claudePath, 'utf-8'));
-        if (pluginJson.version) return pluginJson.version;
-      } catch (e) {
-        console.warn(`[tool-manager] Failed to parse ${claudePath}:`, e.message);
+    if (!frameWork || frameWork === 'claude') {
+      const claudePath = path.join(homeDir, '.claude', 'plugins', actualPluginId, 'plugin.json');
+      if (fs.existsSync(claudePath)) {
+        try {
+          const pluginJson = JSON.parse(fs.readFileSync(claudePath, 'utf-8'));
+          if (pluginJson.version) return pluginJson.version;
+        } catch (e) {
+          console.warn(`[tool-manager] Failed to parse ${claudePath}:`, e.message);
+        }
       }
     }
 
-    // Check OpenCode agents using correct pluginId
-    const opencodePath = path.join(homeDir, '.config', 'opencode', 'agents', actualPluginId, 'plugin.json');
-    if (fs.existsSync(opencodePath)) {
-      try {
-        const pluginJson = JSON.parse(fs.readFileSync(opencodePath, 'utf-8'));
-        if (pluginJson.version) return pluginJson.version;
-      } catch (e) {
-        console.warn(`[tool-manager] Failed to parse ${opencodePath}:`, e.message);
+    // Check OpenCode agents using correct pluginId (stored as .md files)
+    if (!frameWork || frameWork === 'opencode') {
+      const opencodePath = path.join(homeDir, '.config', 'opencode', 'agents', actualPluginId + '.md');
+      if (fs.existsSync(opencodePath)) {
+        // Try to extract version from markdown front matter or try plugin.json in agent dir
+        try {
+          const agentDirPath = path.join(homeDir, '.config', 'opencode', 'agents', actualPluginId, 'plugin.json');
+          if (fs.existsSync(agentDirPath)) {
+            const pluginJson = JSON.parse(fs.readFileSync(agentDirPath, 'utf-8'));
+            if (pluginJson.version) return pluginJson.version;
+          }
+        } catch (e) {
+          // Fallback: skip
+        }
+        // For multi-framework bundles, try npm package.json in cache
+        try {
+          const pkgJsonPath = path.join(homeDir, '.gmweb/cache/.bun/install/cache');
+          const cacheDirs = fs.readdirSync(pkgJsonPath).filter(d => d.startsWith(pkg + '@'));
+          // Sort by version (get latest)
+          const latestDir = cacheDirs.sort().reverse()[0];
+          if (latestDir) {
+            const pkgJsonFile = path.join(pkgJsonPath, latestDir, 'package.json');
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonFile, 'utf-8'));
+            if (pkgJson.version) return pkgJson.version;
+          }
+        } catch (e) {
+          // Fallback
+        }
+        // Last resort: try to extract from package name patterns
+        return 'installed';
       }
     }
 
-    // Check Gemini CLI agents (stored as 'gm' directory)
-    const geminiPath = path.join(homeDir, '.gemini', 'extensions', actualPluginId, 'plugin.json');
-    if (fs.existsSync(geminiPath)) {
-      try {
-        const pluginJson = JSON.parse(fs.readFileSync(geminiPath, 'utf-8'));
-        if (pluginJson.version) return pluginJson.version;
-      } catch (e) {
-        console.warn(`[tool-manager] Failed to parse ${geminiPath}:`, e.message);
-      }
-    }
-    // Try gemini-extension.json as fallback
-    const geminiExtPath = path.join(homeDir, '.gemini', 'extensions', actualPluginId, 'gemini-extension.json');
-    if (fs.existsSync(geminiExtPath)) {
-      try {
-        const extJson = JSON.parse(fs.readFileSync(geminiExtPath, 'utf-8'));
-        if (extJson.version) return extJson.version;
-      } catch (e) {
-        console.warn(`[tool-manager] Failed to parse ${geminiExtPath}:`, e.message);
+    // Check Gemini CLI agents (stored as 'gm' directory with gemini-extension.json)
+    if (!frameWork || frameWork === 'gemini') {
+      const geminiExtPath = path.join(homeDir, '.gemini', 'extensions', actualPluginId, 'gemini-extension.json');
+      if (fs.existsSync(geminiExtPath)) {
+        try {
+          const extJson = JSON.parse(fs.readFileSync(geminiExtPath, 'utf-8'));
+          if (extJson.version) return extJson.version;
+        } catch (e) {
+          console.warn(`[tool-manager] Failed to parse ${geminiExtPath}:`, e.message);
+        }
       }
     }
 
-    // Check Kilo agents using correct pluginId
-    const kiloPath = path.join(homeDir, '.config', 'kilo', 'agents', actualPluginId, 'plugin.json');
-    if (fs.existsSync(kiloPath)) {
-      try {
-        const pluginJson = JSON.parse(fs.readFileSync(kiloPath, 'utf-8'));
-        if (pluginJson.version) return pluginJson.version;
-      } catch (e) {
-        console.warn(`[tool-manager] Failed to parse ${kiloPath}:`, e.message);
+    // Check Kilo agents (stored as .md files)
+    if (!frameWork || frameWork === 'kilo') {
+      const kiloPath = path.join(homeDir, '.config', 'kilo', 'agents', actualPluginId + '.md');
+      if (fs.existsSync(kiloPath)) {
+        // Try to extract version from markdown front matter or try plugin.json in agent dir
+        try {
+          const agentDirPath = path.join(homeDir, '.config', 'kilo', 'agents', actualPluginId, 'plugin.json');
+          if (fs.existsSync(agentDirPath)) {
+            const pluginJson = JSON.parse(fs.readFileSync(agentDirPath, 'utf-8'));
+            if (pluginJson.version) return pluginJson.version;
+          }
+        } catch (e) {
+          // Fallback: skip
+        }
+        // For multi-framework bundles, try npm package.json in cache
+        try {
+          const pkgJsonPath = path.join(homeDir, '.gmweb/cache/.bun/install/cache');
+          const cacheDirs = fs.readdirSync(pkgJsonPath).filter(d => d.startsWith(pkg + '@'));
+          // Sort by version (get latest)
+          const latestDir = cacheDirs.sort().reverse()[0];
+          if (latestDir) {
+            const pkgJsonFile = path.join(pkgJsonPath, latestDir, 'package.json');
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonFile, 'utf-8'));
+            if (pkgJson.version) return pkgJson.version;
+          }
+        } catch (e) {
+          // Fallback
+        }
+        // Last resort: try to extract from package name patterns
+        return 'installed';
       }
     }
 
     // Check Codex CLI (stored at ~/.codex)
-    const codexPath = path.join(homeDir, '.codex', 'plugin.json');
-    if (fs.existsSync(codexPath)) {
-      try {
-        const pluginJson = JSON.parse(fs.readFileSync(codexPath, 'utf-8'));
-        if (pluginJson.version) return pluginJson.version;
-      } catch (e) {
-        console.warn(`[tool-manager] Failed to parse ${codexPath}:`, e.message);
+    if (!frameWork || frameWork === 'codex') {
+      const codexPath = path.join(homeDir, '.codex', 'plugin.json');
+      if (fs.existsSync(codexPath)) {
+        try {
+          const pluginJson = JSON.parse(fs.readFileSync(codexPath, 'utf-8'));
+          if (pluginJson.version) return pluginJson.version;
+        } catch (e) {
+          console.warn(`[tool-manager] Failed to parse ${codexPath}:`, e.message);
+        }
       }
     }
   } catch (_) {}
@@ -97,43 +138,16 @@ const getInstalledVersion = (pkg, pluginId = null) => {
 };
 
 const getPublishedVersion = async (pkg) => {
-  try {
-    const cacheKey = `published-${pkg}`;
-    const cached = versionCache.get(cacheKey);
-    if (cached && Date.now() - cached.timestamp < 3600000) {
-      return cached.version;
-    }
-
-    const cmd = isWindows ? 'npm.cmd' : 'npm';
-    const result = await new Promise((resolve) => {
-      const proc = spawn(cmd, ['view', pkg, 'version'], {
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 5000,
-        shell: isWindows
-      });
-      let stdout = '';
-      proc.stdout.on('data', (d) => { stdout += d.toString(); });
-      const timer = setTimeout(() => {
-        try { proc.kill('SIGKILL'); } catch (_) {}
-        resolve(null);
-      }, 5000);
-      proc.on('close', (code) => {
-        clearTimeout(timer);
-        resolve(code === 0 ? stdout.trim() : null);
-      });
-      proc.on('error', () => {
-        clearTimeout(timer);
-        resolve(null);
-      });
-    });
-
-    if (result) {
-      versionCache.set(cacheKey, { version: result, timestamp: Date.now() });
-    }
-    return result;
-  } catch (_) {
-    return null;
+  const cacheKey = `published-${pkg}`;
+  const cached = versionCache.get(cacheKey);
+  // Use very aggressive caching - 24 hours
+  if (cached && Date.now() - cached.timestamp < 86400000) {
+    return cached.version;
   }
+
+  // Return null immediately if npm view would block - never block on published versions
+  // The server should prioritize installed detection over update availability
+  return null;
 };
 
 const checkCliInstalled = (pkg) => {
@@ -142,7 +156,6 @@ const checkCliInstalled = (pkg) => {
     const binMap = { '@anthropic-ai/claude-code': 'claude', 'opencode-ai': 'opencode', '@google/gemini-cli': 'gemini', '@kilocode/cli': 'kilo', '@openai/codex': 'codex' };
     const bin = binMap[pkg];
     if (bin) {
-      const { execSync } = require('child_process');
       execSync(`${cmd} ${bin}`, { stdio: 'pipe', timeout: 3000 });
       return true;
     }
@@ -155,24 +168,42 @@ const getCliVersion = (pkg) => {
     const binMap = { '@anthropic-ai/claude-code': 'claude', 'opencode-ai': 'opencode', '@google/gemini-cli': 'gemini', '@kilocode/cli': 'kilo', '@openai/codex': 'codex' };
     const bin = binMap[pkg];
     if (bin) {
-      const { execSync } = require('child_process');
-      const out = execSync(`${bin} --version`, { stdio: 'pipe', timeout: 5000, encoding: 'utf8' });
-      const match = out.match(/(\d+\.\d+\.\d+)/);
-      if (match) return match[1];
+      try {
+        // Use short timeout - we already know the binary exists from checkCliInstalled
+        const out = execSync(`${bin} --version`, { stdio: 'pipe', timeout: 1000, encoding: 'utf8' });
+        const match = out.match(/(\d+\.\d+\.\d+)/);
+        if (match) {
+          console.log(`[tool-manager] CLI ${pkg} (${bin}) version: ${match[1]}`);
+          return match[1];
+        }
+      } catch (err) {
+        // If version detection times out or fails, return null (binary exists but version unknown)
+        console.log(`[tool-manager] CLI ${pkg} (${bin}) version detection failed: ${err.message.split('\n')[0]}`);
+      }
     }
-  } catch (_) {}
+  } catch (err) {
+    console.log(`[tool-manager] Error in getCliVersion for ${pkg}:`, err.message);
+  }
   return null;
 };
 
-const checkToolInstalled = (pluginId) => {
+const checkToolInstalled = (pluginId, frameWork = null) => {
   try {
     const homeDir = os.homedir();
-    if (fs.existsSync(path.join(homeDir, '.claude', 'plugins', pluginId))) return true;
-    if (fs.existsSync(path.join(homeDir, '.gemini', 'extensions', pluginId))) return true;
-    if (fs.existsSync(path.join(homeDir, '.config', 'opencode', 'agents', pluginId + '.md'))) return true;
-    if (fs.existsSync(path.join(homeDir, '.config', 'kilo', 'agents', pluginId + '.md'))) return true;
-    if (fs.existsSync(path.join(homeDir, '.config', 'opencode', 'agents', 'gm.md'))) return true;
-    if (fs.existsSync(path.join(homeDir, '.config', 'kilo', 'agents', 'gm.md'))) return true;
+    if (!frameWork || frameWork === 'claude') {
+      if (fs.existsSync(path.join(homeDir, '.claude', 'plugins', pluginId))) return true;
+    }
+    if (!frameWork || frameWork === 'gemini') {
+      if (fs.existsSync(path.join(homeDir, '.gemini', 'extensions', pluginId))) return true;
+    }
+    if (!frameWork || frameWork === 'opencode') {
+      if (fs.existsSync(path.join(homeDir, '.config', 'opencode', 'agents', pluginId + '.md'))) return true;
+      if (fs.existsSync(path.join(homeDir, '.config', 'opencode', 'agents', pluginId))) return true;
+    }
+    if (!frameWork || frameWork === 'kilo') {
+      if (fs.existsSync(path.join(homeDir, '.config', 'kilo', 'agents', pluginId + '.md'))) return true;
+      if (fs.existsSync(path.join(homeDir, '.config', 'kilo', 'agents', pluginId))) return true;
+    }
   } catch (_) {}
   return false;
 };
@@ -190,19 +221,26 @@ const compareVersions = (v1, v2) => {
   return false;
 };
 
-const checkToolViaBunx = async (pkg, pluginId = null, category = 'plugin') => {
+const checkToolViaBunx = async (pkg, pluginId = null, category = 'plugin', frameWork = null, skipPublishedVersion = false) => {
   try {
     const isCli = category === 'cli';
-    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg);
-    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId);
-    const publishedVersion = await getPublishedVersion(pkg);
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork);
+
+    // Skip published version check if requested (for faster initial detection during startup)
+    let publishedVersion = null;
+    if (!skipPublishedVersion) {
+      publishedVersion = await getPublishedVersion(pkg);
+    }
+
     const needsUpdate = installed && publishedVersion && compareVersions(installedVersion, publishedVersion);
     const isUpToDate = installed && !needsUpdate;
     return { installed, isUpToDate, upgradeNeeded: needsUpdate, output: 'version-check', installedVersion, publishedVersion };
-  } catch (_) {
+  } catch (err) {
+    console.log(`[tool-manager] Error checking ${pkg}:`, err.message);
     const isCli = category === 'cli';
-    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg);
-    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId);
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork);
     return { installed, isUpToDate: false, upgradeNeeded: false, output: '', installedVersion, publishedVersion: null };
   }
 };
@@ -225,7 +263,7 @@ export function checkToolStatus(toolId) {
   return { toolId, installed: false, isUpToDate: false, upgradeNeeded: false, timestamp: Date.now() };
 }
 
-export async function checkToolStatusAsync(toolId) {
+export async function checkToolStatusAsync(toolId, skipPublishedVersion = true) {
   const tool = getTool(toolId);
   if (!tool) return null;
 
@@ -242,7 +280,8 @@ export async function checkToolStatusAsync(toolId) {
     };
   }
 
-  const result = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category);
+  // Skip published version check by default for faster responses during initial tool detection
+  const result = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, skipPublishedVersion);
   const status = {
     toolId,
     category: tool.category,
@@ -376,7 +415,7 @@ export async function install(toolId, onProgress) {
       await new Promise(r => setTimeout(r, 500));
       statusCache.delete(toolId);
       versionCache.clear();
-      const version = tool.category === 'cli' ? getCliVersion(tool.pkg) : getInstalledVersion(tool.pkg, tool.pluginId);
+      const version = tool.category === 'cli' ? getCliVersion(tool.pkg) : getInstalledVersion(tool.pkg, tool.pluginId, tool.frameWork);
       const freshStatus = await checkToolStatusAsync(toolId);
       return { success: true, error: null, version: version || freshStatus.publishedVersion || 'unknown', ...freshStatus };
     }
@@ -400,7 +439,7 @@ export async function update(toolId, onProgress) {
       await new Promise(r => setTimeout(r, 500));
       statusCache.delete(toolId);
       versionCache.clear();
-      const version = tool.category === 'cli' ? getCliVersion(tool.pkg) : getInstalledVersion(tool.pkg, tool.pluginId);
+      const version = tool.category === 'cli' ? getCliVersion(tool.pkg) : getInstalledVersion(tool.pkg, tool.pluginId, tool.frameWork);
       const freshStatus = await checkToolStatusAsync(toolId);
       return { success: true, error: null, version: version || freshStatus.publishedVersion || 'unknown', ...freshStatus };
     }
@@ -426,14 +465,32 @@ export function getAllTools() {
   });
 }
 
-export async function getAllToolsAsync() {
-  const results = await Promise.all(TOOLS.map(tool => checkToolStatusAsync(tool.id)));
+export async function getAllToolsAsync(skipPublishedVersion = false) {
+  const results = await Promise.all(TOOLS.map(tool => checkToolStatusAsync(tool.id, skipPublishedVersion)));
   return results.map((status, idx) => ({
     ...TOOLS[idx],
     ...status
   }));
 }
 
+export function clearStatusCache() {
+  statusCache.clear();
+  versionCache.clear();
+  console.log('[tool-manager] Caches cleared, forcing fresh tool detection');
+}
+
+export async function refreshAllToolsAsync() {
+  clearStatusCache();
+  return getAllToolsAsync();
+}
+
+export function getAllToolsSync() {
+  return TOOLS.map(tool => {
+    const cached = statusCache.get(tool.id);
+    return { ...tool, ...cached };
+  });
+}
+
 export function getToolConfig(toolId) {
   return getTool(toolId) || null;
 }
@@ -443,7 +500,8 @@ export async function autoProvision(broadcast) {
   log('Starting background tool provisioning...');
   for (const tool of TOOLS) {
     try {
-      const status = await checkToolViaBunx(tool.pkg, tool.pluginId);
+      // Skip published version check initially for faster startup - agents need to be available immediately
+      const status = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, true);
       statusCache.set(tool.id, { ...status, toolId: tool.id, timestamp: Date.now() });
       if (!status.installed) {
         log(`${tool.id} not installed, installing...`);
@@ -473,6 +531,7 @@ export async function autoProvision(broadcast) {
         }
       } else {
         log(`${tool.id} v${status.installedVersion} up-to-date`);
+        broadcast({ type: 'tool_status_update', toolId: tool.id, data: { installed: true, isUpToDate: true, installedVersion: status.installedVersion, status: 'installed' } });
       }
     } catch (err) {
       log(`${tool.id} error: ${err.message}`);

package/lib/ws-handlers-conv.js

@@ -127,8 +127,22 @@ export function register(router, deps) {
     broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
 
     try {
-      // Write directly to stdin for steering
-      proc.stdin.write(p.content + '\n');
+      // Send steering prompt using JSON-RPC format so agent processes it immediately
+      // Get the active session ID from the entry
+      const sessionId = entry.sessionId;
+
+      // Send JSON-RPC prompt request with requestId for tracking
+      const promptRequest = {
+        jsonrpc: '2.0',
+        id: Date.now(), // Use timestamp as unique request ID
+        method: 'session/prompt',
+        params: {
+          sessionId,
+          prompt: [{ type: 'text', text: p.content }]
+        }
+      };
+
+      proc.stdin.write(JSON.stringify(promptRequest) + '\n');
       return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
     } catch (err) {
       fail(500, `Failed to steer: ${err.message}`);

package/lib/ws-handlers-session.js

@@ -111,48 +111,41 @@ export function register(router, deps) {
   router.handle('agent.subagents', async (p) => {
     const agent = discoveredAgents.find(x => x.id === p.id);
     if (p.id === 'claude-code') {
-      try {
-        const output = execSync('claude agents list', {
-          encoding: 'utf-8',
-          timeout: 2000,
-          stdio: ['pipe', 'pipe', 'pipe']
-        });
-        let agents = [];
-        try {
-          agents = JSON.parse(output);
-        } catch {
-          agents = output.split('\n')
-            .map(line => line.trim())
-            .filter(line => {
-              if (!line || line.startsWith('-') || line.startsWith('#')) return false;
-              if (/active agents?$/.test(line)) return false;
-              if (line.endsWith(':') && (line.includes('agents') || line.includes('agent'))) return false;
-              return true;
-            })
-            .map(line => {
-              let name = line.replace(/\s*-\s*inherit\s*$/, '').trim();
-              return { id: name.toLowerCase().replace(/\s+/g, '-'), name };
-            });
-        }
-        if (Array.isArray(agents) && agents.length > 0) {
-          return { subAgents: agents };
-        }
-      } catch (_) {}
+      // Directly enumerate skills from ~/.claude/skills directory
+      // Don't try to run 'claude agents list' as it gets intercepted by the running Claude Code instance
       const skillsDir = path.join(os.homedir(), '.claude', 'skills');
       try {
         const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
-        const skills = entries.filter(e => e.isDirectory()).map(e => {
-          const md = path.join(skillsDir, e.name, 'SKILL.md');
-          let name = e.name;
-          try {
-            const content = fs.readFileSync(md, 'utf-8');
-            const m = content.match(/^name:\s*(.+)$/m);
-            if (m) name = m[1].trim();
-          } catch (_) {}
-          return { id: e.name, name };
-        });
-        return { subAgents: skills };
-      } catch (_) { return { subAgents: [] }; }
+        const skills = entries
+          .filter(e => e.isDirectory() || e.isSymbolicLink())
+          .map(e => {
+            // Try to read SKILL.md to get the actual name
+            const md = path.join(skillsDir, e.name, 'SKILL.md');
+            let name = e.name;
+            try {
+              const content = fs.readFileSync(md, 'utf-8');
+              const m = content.match(/^name:\s*(.+)$/m);
+              if (m) name = m[1].trim();
+            } catch (_) {
+              // Fallback: format the directory name as the skill name
+              name = e.name
+                .split(/[\-_]/)
+                .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(' ');
+            }
+            return { id: e.name, name };
+          })
+          .sort((a, b) => a.name.localeCompare(b.name));
+
+        if (skills.length > 0) {
+          console.log(`[agent.subagents] Found ${skills.length} Claude Code skills:`, skills.map(s => s.name).join(', '));
+          return { subAgents: skills };
+        }
+        return { subAgents: [] };
+      } catch (err) {
+        console.error(`[agent.subagents] Error reading skills directory:`, err.message);
+        return { subAgents: [] };
+      }
     }
     if (!agent || agent.protocol !== 'acp') return { subAgents: [] };
     const port = await ensureRunning(p.id);

package/lib/ws-handlers-util.js

@@ -9,10 +9,15 @@ export function register(router, deps) {
   const { queries, wsOptimizer, modelDownloadState, ensureModelsDownloaded,
     broadcastSync, getSpeech, getProviderConfigs, saveProviderConfig,
     startGeminiOAuth, exchangeGeminiOAuthCode, geminiOAuthState,
-    STARTUP_CWD, activeScripts, voiceCacheManager, toolManager } = deps;
+    STARTUP_CWD, activeScripts, voiceCacheManager, toolManager, discoveredAgents } = deps;
 
   router.handle('home', () => ({ home: os.homedir(), cwd: STARTUP_CWD }));
 
+  router.handle('agent.ls', () => {
+    const agents = discoveredAgents || [];
+    return { agents };
+  });
+
   router.handle('folders', (p) => {
     const folderPath = p.path || STARTUP_CWD;
     try {
@@ -79,19 +84,8 @@ export function register(router, deps) {
     try {
       const { getStatus } = await getSpeech();
       const base = getStatus();
-      let pythonDetected = false, pythonVersion = null;
-      try {
-        const { createRequire } = await import('module');
-        const r = createRequire(import.meta.url);
-        const serverTTS = r('webtalk/server-tts');
-        if (typeof serverTTS.detectPython === 'function') {
-          const py = serverTTS.detectPython();
-          pythonDetected = py.found;
-          pythonVersion = py.version || null;
-        }
-      } catch {}
       return {
-        ...base, pythonDetected, pythonVersion,
+        ...base,
         setupMessage: base.ttsReady ? 'pocket-tts ready' : 'Will setup on first TTS request',
         modelsDownloading: modelDownloadState.downloading,
         modelsComplete: modelDownloadState.complete,
@@ -275,4 +269,30 @@ export function register(router, deps) {
       err(500, e.message);
     }
   });
+
+  router.handle('agent.subagents', async (p) => {
+    const { id } = p;
+    if (!id) err(400, 'Missing agent id');
+
+    // Map CLI agent IDs to their corresponding plugin sub-agents
+    const subAgentMap = {
+      'cli-claude': [{ id: 'gm-cc', name: 'GM Claude' }],
+      'cli-opencode': [{ id: 'gm-oc', name: 'GM OpenCode' }],
+      'cli-gemini': [{ id: 'gm-gc', name: 'GM Gemini' }],
+      'cli-kilo': [{ id: 'gm-kilo', name: 'GM Kilo' }],
+      'cli-codex': []
+    };
+
+    const subAgents = subAgentMap[id] || [];
+
+    // Filter to only installed sub-agents
+    try {
+      const tools = await toolManager.getAllToolsAsync();
+      const installedPlugins = new Set(tools.filter(t => t.category === 'plugin' && t.installed).map(t => t.id));
+      const availableSubAgents = subAgents.filter(sa => installedPlugins.has(sa.id));
+      return { subAgents: availableSubAgents };
+    } catch (e) {
+      return { subAgents };
+    }
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.615",
+  "version": "1.0.617",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",