overmind-mcp 2.8.6 → 2.8.8

package/dist/services/AgentManager.js

@@ -35,30 +35,36 @@ export class AgentManager {
         }
     }
     async listAgents(details = false) {
-        const agentsDir = path.join(this.claudeDir, 'agents');
-        await fs.mkdir(agentsDir, { recursive: true });
-        const files = await fs.readdir(agentsDir);
-        const agentFiles = files.filter((f) => f.endsWith('.md'));
-        const agentsList = [];
+        const workspaceDir = getWorkspaceDir();
+        const claudeAgentsDir = path.join(this.claudeDir, 'agents');
+        await fs.mkdir(claudeAgentsDir, { recursive: true });
+        // 1. Scan .claude/agents/*.md
+        const claudeFiles = await fs.readdir(claudeAgentsDir).catch(() => []);
+        const claudeAgentNames = claudeFiles.filter((f) => f.endsWith('.md')).map((f) => f.replace('.md', ''));
+        // 2. Scan .overmind/hermes/agent_*
+        const hermesDir = path.join(workspaceDir, '.overmind', 'hermes');
+        const hermesDirs = await fs.readdir(hermesDir).catch(() => []);
+        const hermesAgentNames = hermesDirs
+            .filter((d) => d.startsWith('agent_'))
+            .map((d) => d.replace('agent_', ''));
+        const agentsMap = new Map();
         const availableServers = await this.getAvailableMcpServers();
-        for (const file of agentFiles) {
-            const agentName = file.replace('.md', '');
-            if (!details) {
-                agentsList.push(`- ${agentName}`);
-                continue;
-            }
-            let info = `🤖 **${agentName}**`;
-            const settingsPath = path.join(this.claudeDir, `settings_${agentName}.json`);
+        // Process Claude agents
+        for (const name of claudeAgentNames) {
+            let runner = 'claude';
+            let model = 'settings-default';
+            let provider = 'auto';
+            let mcpServers = [];
+            let missingConfig = false;
+            const settingsPath = path.join(this.claudeDir, `settings_${name}.json`);
             try {
                 const settingsContent = await fs.readFile(settingsPath, 'utf-8');
                 let settings = JSON.parse(settingsContent);
-                // --- New interpolation logic ---
                 settings = interpolateEnvVars(settings);
-                const model = settings.env?.ANTHROPIC_MODEL || settings.model || 'settings-default';
-                const runner = settings.runner || 'claude';
-                const servers = settings.enabledMcpjsonServers || [];
-                // Inférence du provider
-                let provider = settings.provider || settings.env?.PROVIDER || 'auto';
+                model = settings.env?.ANTHROPIC_MODEL || settings.model || 'settings-default';
+                runner = settings.runner || 'claude';
+                mcpServers = settings.enabledMcpjsonServers || [];
+                provider = settings.provider || settings.env?.PROVIDER || 'auto';
                 if (provider === 'auto') {
                     if (settings.env?.MISTRAL_API_KEY)
                         provider = 'mistral';
@@ -68,9 +74,7 @@ export class AgentManager {
                         provider = 'nvidia';
                     else if (settings.env?.GEMINI_API_KEY)
                         provider = 'google';
-                    else if (model.includes('mistral') ||
-                        model.includes('codestral') ||
-                        model.includes('devstral'))
+                    else if (model.includes('mistral') || model.includes('codestral') || model.includes('devstral'))
                         provider = 'mistral';
                     else if (model.includes('gpt-'))
                         provider = 'openai';
@@ -79,44 +83,189 @@ export class AgentManager {
                     else if (model.includes('claude'))
                         provider = 'anthropic';
                 }
-                const serverStatus = servers.map((s) => {
-                    if (availableServers.includes(s))
-                        return s;
-                    // Recherche de suggestions (typo)
-                    const suggestion = availableServers.find((v) => v.toLowerCase().includes(s.toLowerCase()) ||
-                        s.toLowerCase().includes(v.toLowerCase()));
-                    return suggestion
-                        ? `${s} (⚠️ Nom incorrect ? Suggestion: **${suggestion}**)`
-                        : `${s} (⚠️ Absent de mcp.json)`;
+            }
+            catch {
+                missingConfig = true;
+            }
+            let promptSize = 0;
+            try {
+                const stat = await fs.stat(path.join(claudeAgentsDir, `${name}.md`));
+                promptSize = stat.size;
+            }
+            catch {
+                // Ignored
+            }
+            agentsMap.set(name, {
+                name,
+                runner,
+                model,
+                provider,
+                mcpServers,
+                origin: 'claude',
+                missingConfig,
+                promptSize,
+            });
+        }
+        // Process Hermes agents
+        for (const name of hermesAgentNames) {
+            let model = 'MiniMax-M2.7';
+            let provider = 'minimax-cn';
+            let mcpServers = ['memory-server', 'postgresql-server', 'twilio-mcp'];
+            let promptSize = 0;
+            const agentHermesDir = path.join(hermesDir, `agent_${name}`, '.hermes');
+            try {
+                const soulStat = await fs.stat(path.join(agentHermesDir, 'SOUL.md'));
+                promptSize = soulStat.size;
+            }
+            catch {
+                // Ignored
+            }
+            // Try reading .env to get actual model and provider
+            const envPath = path.join(agentHermesDir, '.env');
+            try {
+                const content = await fs.readFile(envPath, 'utf-8');
+                content.split('\n').forEach((line) => {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#'))
+                        return;
+                    const eqIdx = trimmed.indexOf('=');
+                    if (eqIdx === -1)
+                        return;
+                    const k = trimmed.slice(0, eqIdx).trim();
+                    let v = trimmed.slice(eqIdx + 1).trim();
+                    if (v.startsWith('"') && v.endsWith('"'))
+                        v = v.slice(1, -1);
+                    else if (v.startsWith("'") && v.endsWith("'"))
+                        v = v.slice(1, -1);
+                    if (k === 'MODEL' || k === 'ANTHROPIC_MODEL') {
+                        model = v;
+                    }
+                    else if (k === 'PROVIDER' || k === 'ANTHROPIC_PROVIDER') {
+                        provider = v;
+                    }
                 });
-                info += `\n  - Runner  : ${runner}`;
-                info += `\n  - Model   : ${model}`;
-                info += `\n  - Provider: ${provider}`;
-                info += `\n  - Serveurs MCP : ${servers.length > 0 ? serverStatus.join(', ') : 'Aucun'}`;
             }
-            catch (_e) {
-                info += `\n  - Config : ⚠️ Manquante ou invalide (${settingsPath})`;
+            catch {
+                // Ignored
             }
+            // Try reading config.yaml to get actual MCP servers
+            const yamlPath = path.join(agentHermesDir, 'config.yaml');
             try {
-                const promptPath = path.join(agentsDir, file);
-                const promptStat = await fs.stat(promptPath);
-                info += `\n  - Prompt Size : ${promptStat.size} bytes`;
+                const yamlContent = await fs.readFile(yamlPath, 'utf-8');
+                const parsedMcp = [];
+                const serverBlocks = yamlContent.split('\n  ');
+                serverBlocks.forEach((block) => {
+                    const lines = block.split('\n');
+                    const header = lines[0].trim();
+                    if (header && header.endsWith(':') && header !== 'mcp_servers:') {
+                        parsedMcp.push(header.slice(0, -1).trim());
+                    }
+                });
+                if (parsedMcp.length > 0)
+                    mcpServers = parsedMcp;
             }
-            catch (_e) {
-                // Ignore missing or inaccessible prompt file
+            catch {
+                // Ignored
             }
-            agentsList.push(info);
+            if (!agentsMap.has(name)) {
+                agentsMap.set(name, {
+                    name,
+                    runner: 'hermes',
+                    model,
+                    provider,
+                    mcpServers,
+                    origin: 'hermes',
+                    missingConfig: false,
+                    promptSize,
+                });
+            }
+            else {
+                const existing = agentsMap.get(name);
+                if (existing.runner === 'claude' && existing.missingConfig) {
+                    existing.runner = 'hermes';
+                    existing.missingConfig = false;
+                }
+            }
+        } // Group by runner
+        const runners = ['hermes', 'claude', 'kilo', 'gemini', 'qwencli', 'openclaw', 'cline', 'opencode'];
+        const grouped = new Map();
+        for (const r of runners) {
+            grouped.set(r, []);
         }
-        return agentsList;
+        grouped.set('unknown/other', []);
+        for (const agent of agentsMap.values()) {
+            const r = agent.runner.toLowerCase();
+            if (grouped.has(r)) {
+                grouped.get(r).push(agent);
+            }
+            else {
+                grouped.get('unknown/other').push(agent);
+            }
+        }
+        const outputLines = [];
+        for (const [runName, list] of grouped.entries()) {
+            if (list.length === 0)
+                continue;
+            let sectionText = `### 🏃 Runner/Harnais : **${runName.toUpperCase()}** (${list.length} agent(s))\n`;
+            const items = [];
+            for (const agent of list) {
+                if (!details) {
+                    const warnText = agent.missingConfig ? ' ⚠️ (Config settings manquante)' : '';
+                    items.push(`  - **${agent.name}**${warnText}`);
+                }
+                else {
+                    let agentDesc = `  - **${agent.name}**`;
+                    if (agent.missingConfig) {
+                        agentDesc += `\n    ⚠️ Config settings manquante (settings_${agent.name}.json)`;
+                    }
+                    else {
+                        agentDesc += `\n    - Modèle   : ${agent.model}`;
+                        agentDesc += `\n    - Provider : ${agent.provider}`;
+                        const serverStatus = agent.mcpServers.map((s) => {
+                            if (availableServers.includes(s))
+                                return s;
+                            const sugg = availableServers.find(v => v.toLowerCase().includes(s.toLowerCase()) || s.toLowerCase().includes(v.toLowerCase()));
+                            return sugg ? `${s} (⚠️ Suggestion: ${sugg})` : `${s} (⚠️ Absent)`;
+                        });
+                        agentDesc += `\n    - MCPs     : ${serverStatus.length > 0 ? serverStatus.join(', ') : 'Aucun'}`;
+                    }
+                    agentDesc += `\n    - Prompt   : ${agent.promptSize} bytes (${agent.origin === 'hermes' ? 'SOUL.md' : 'agents/' + agent.name + '.md'})`;
+                    items.push(agentDesc);
+                }
+            }
+            sectionText += items.join('\n');
+            outputLines.push(sectionText);
+        }
+        return outputLines;
     }
     async deleteAgent(name) {
         validateAgentName(name);
+        const workspaceDir = getWorkspaceDir();
+        const hermesAgentDir = path.join(workspaceDir, '.overmind', 'hermes', `agent_${name}`);
+        let isHermes = false;
+        try {
+            const stat = await fs.stat(hermesAgentDir);
+            isHermes = stat.isDirectory();
+        }
+        catch {
+            // Ignored
+        }
+        const deletedFiles = [];
+        const errors = [];
+        if (isHermes) {
+            try {
+                await fs.rm(hermesAgentDir, { recursive: true, force: true });
+                deletedFiles.push(hermesAgentDir);
+            }
+            catch (e) {
+                errors.push(`hermes_dir: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return { deletedFiles, errors };
+        }
         const agentsDir = path.join(this.claudeDir, 'agents');
         const promptPath = path.join(agentsDir, `${name}.md`);
         const settingsPath = path.join(this.claudeDir, `settings_${name}.json`);
         const tmpMcpPath = path.join(this.claudeDir, `mcp_${name}_tmp.json`);
-        const deletedFiles = [];
-        const errors = [];
         for (const file of [promptPath, settingsPath, tmpMcpPath]) {
             try {
                 await fs.unlink(file);
@@ -134,33 +283,154 @@ export class AgentManager {
         validateAgentName(name);
         const changes = [];
         const claudeDir = this.claudeDir;
+        const workspaceDir = getWorkspaceDir();
+        const hermesAgentDir = path.join(workspaceDir, '.overmind', 'hermes', `agent_${name}`);
+        const hermesSubDir = path.join(hermesAgentDir, '.hermes');
+        let isHermes = false;
+        try {
+            const stat = await fs.stat(hermesAgentDir);
+            isHermes = stat.isDirectory();
+        }
+        catch {
+            // Ignored
+        }
         // --- MODE RÉÉCRITURE DE FICHIER COMPLET ---
         if (updates.file && updates.content) {
-            let filePath;
-            switch (updates.file) {
-                case 'prompt.md':
-                    filePath = path.join(claudeDir, 'agents', `${name}.md`);
-                    break;
-                case 'settings.json':
-                    filePath = path.join(claudeDir, `settings_${name}.json`);
-                    break;
-                case '.mcp.json':
-                    filePath = path.join(claudeDir, `.mcp.${name}.json`);
-                    break;
-                case 'skill.md':
-                    filePath = path.join(claudeDir, 'agents', `${name}_skill.md`);
-                    await fs.mkdir(path.dirname(filePath), { recursive: true });
-                    break;
-                default:
-                    throw new Error(`Fichier non supporté: ${updates.file}`);
-            }
-            await fs.writeFile(filePath, updates.content, 'utf-8');
-            changes.push(`✅ Fichier **${updates.file}** réécrit pour l'agent **${name}**.`);
-            // Si on réécrit settings.json, on ne fait pas les updates unitaires (déjà écrasé)
-            if (updates.file === 'settings.json')
+            if (isHermes) {
+                let filePath;
+                switch (updates.file) {
+                    case 'prompt.md':
+                        filePath = path.join(hermesSubDir, 'SOUL.md');
+                        await fs.writeFile(filePath, updates.content, 'utf-8');
+                        changes.push(`✅ Fichier **SOUL.md** réécrit pour l'agent Hermes **${name}**.`);
+                        break;
+                    case 'settings.json': {
+                        let envStr = '';
+                        try {
+                            const s = JSON.parse(updates.content);
+                            if (s.env) {
+                                for (const [k, v] of Object.entries(s.env)) {
+                                    if (typeof v === 'string')
+                                        envStr += `${k}=${v}\n`;
+                                }
+                            }
+                            if (s.model && !envStr.includes('MODEL='))
+                                envStr += `MODEL=${s.model}\n`;
+                            if (s.runner && !envStr.includes('RUNNER='))
+                                envStr += `RUNNER=${s.runner}\n`;
+                        }
+                        catch {
+                            envStr = updates.content;
+                        }
+                        filePath = path.join(hermesSubDir, '.env');
+                        await fs.writeFile(filePath, envStr, 'utf-8');
+                        changes.push(`✅ Fichier **.env** réécrit pour l'agent Hermes **${name}**.`);
+                        break;
+                    }
+                    case '.mcp.json': {
+                        let yamlContent = 'mcp_servers:\n';
+                        try {
+                            const mc = JSON.parse(updates.content);
+                            for (const [sName, srv] of Object.entries(mc.mcpServers || {})) {
+                                const s = srv;
+                                yamlContent += `  ${sName}:\n`;
+                                if (s.url)
+                                    yamlContent += `    url: "${s.url}"\n`;
+                                if (s.command)
+                                    yamlContent += `    command: "${s.command}"\n`;
+                            }
+                        }
+                        catch {
+                            yamlContent = updates.content;
+                        }
+                        filePath = path.join(hermesSubDir, 'config.yaml');
+                        await fs.writeFile(filePath, yamlContent, 'utf-8');
+                        changes.push(`✅ Fichier **config.yaml** réécrit pour l'agent Hermes **${name}**.`);
+                        break;
+                    }
+                    case 'skill.md':
+                        filePath = path.join(hermesSubDir, 'skills', 'skill.md');
+                        await fs.mkdir(path.dirname(filePath), { recursive: true });
+                        await fs.writeFile(filePath, updates.content, 'utf-8');
+                        changes.push(`✅ Fichier **skill.md** réécrit pour l'agent Hermes **${name}**.`);
+                        break;
+                    default:
+                        throw new Error(`Fichier non supporté: ${updates.file}`);
+                }
                 return changes;
+            }
+            else {
+                let filePath;
+                switch (updates.file) {
+                    case 'prompt.md':
+                        filePath = path.join(claudeDir, 'agents', `${name}.md`);
+                        break;
+                    case 'settings.json':
+                        filePath = path.join(claudeDir, `settings_${name}.json`);
+                        break;
+                    case '.mcp.json':
+                        filePath = path.join(claudeDir, `.mcp.${name}.json`);
+                        break;
+                    case 'skill.md':
+                        filePath = path.join(claudeDir, 'agents', `${name}_skill.md`);
+                        await fs.mkdir(path.dirname(filePath), { recursive: true });
+                        break;
+                    default:
+                        throw new Error(`Fichier non supporté: ${updates.file}`);
+                }
+                await fs.writeFile(filePath, updates.content, 'utf-8');
+                changes.push(`✅ Fichier **${updates.file}** réécrit pour l'agent **${name}**.`);
+                if (updates.file === 'settings.json')
+                    return changes;
+            }
         }
-        // --- MODE MISE À JOUR UNITAIRE (settings.json) ---
+        if (isHermes) {
+            const envVars = {};
+            const envPath = path.join(hermesSubDir, '.env');
+            try {
+                const content = await fs.readFile(envPath, 'utf-8');
+                content.split('\n').forEach((line) => {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#'))
+                        return;
+                    const eqIdx = trimmed.indexOf('=');
+                    if (eqIdx === -1)
+                        return;
+                    const k = trimmed.slice(0, eqIdx).trim();
+                    let v = trimmed.slice(eqIdx + 1).trim();
+                    if (v.startsWith('"') && v.endsWith('"'))
+                        v = v.slice(1, -1);
+                    else if (v.startsWith("'") && v.endsWith("'"))
+                        v = v.slice(1, -1);
+                    if (k)
+                        envVars[k] = v;
+                });
+            }
+            catch {
+                // Ignored
+            }
+            if (updates.model) {
+                const oldModel = envVars.MODEL || envVars.ANTHROPIC_MODEL;
+                envVars.MODEL = updates.model;
+                changes.push(`- Modèle : ${oldModel} -> ${updates.model}`);
+            }
+            if (updates.env) {
+                for (const [key, value] of Object.entries(updates.env)) {
+                    const oldVal = envVars[key] ? '***' : '(undefined)';
+                    envVars[key] = value;
+                    changes.push(`- Env Var '${key}' : ${oldVal} -> ${value ? '***' : '(vide)'}`);
+                }
+            }
+            if (changes.length > 0) {
+                let newEnvContent = '';
+                for (const [k, v] of Object.entries(envVars)) {
+                    newEnvContent += `${k}=${v}\n`;
+                }
+                await fs.writeFile(envPath, newEnvContent, 'utf-8');
+            }
+            return changes;
+        }
+        // --- MODE MISE À JOUR UNITAIRE (settings.json) pour Claude/Kilo/etc. ---
         const settingsPath = path.join(claudeDir, `settings_${name}.json`);
         let settings;
         try {
@@ -168,7 +438,6 @@ export class AgentManager {
             settings = JSON.parse(content);
         }
         catch (_e) {
-            // Si on veut faire des updates unitaires, le settings doit exister
             if (updates.model ||
                 updates.mcpServers ||
                 updates.env ||
@@ -177,7 +446,7 @@ export class AgentManager {
                 updates.cliPath) {
                 throw new Error(`Impossible de modifier les paramètres unitaires : settings_${name}.json est introuvable.`, { cause: _e });
             }
-            return changes; // Rien à faire
+            return changes;
         }
         if (updates.model) {
             settings.env = settings.env || {};
@@ -194,7 +463,6 @@ export class AgentManager {
             }
             settings.enabledMcpjsonServers = updates.mcpServers;
             changes.push(`- Serveurs MCP : [${oldServers.join(', ')}] -> [${updates.mcpServers.join(', ')}]`);
-            // 📂 UPDATE .mcp.<name>.json
             try {
                 const globalMcpPath = resolveConfigPath(CONFIG.CLAUDE.PATHS.MCP);
                 const globalMcpContent = await fs.readFile(globalMcpPath, 'utf-8');
@@ -245,9 +513,6 @@ export class AgentManager {
         if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
             return { promptPath: '', settingsPath: '', error: 'INVALID_NAME' };
         }
-        const agentsDir = path.join(this.claudeDir, 'agents');
-        await fs.mkdir(this.claudeDir, { recursive: true });
-        await fs.mkdir(agentsDir, { recursive: true });
         const memoryInstructions = `
 
 ---
@@ -272,12 +537,9 @@ Tu es jugé sur ta capacité à transmettre ton savoir. FOUILLIE ta mémoire et
 Tu es conçu pour être exécuté par différents runners (Claude, Kilo, Gemini, Hermes, etc.).
 - **Compatibilité** : Ton prompt et tes compétences sont agnostiques au runner.
 - **Orchestration** : Tu peux être sollicité dans des workflows parallèles (\`run_agents_parallel\`) ou séquentiels.
-- **Auto-Adaptation** : Adapte tes réponses au format attendu par le runner actuel (JSON pour Claude Code, texte brut pour Kilo, etc.).`;
+- **Auto-Évaluation** : Adapte tes réponses au format attendu par le runner actuel (JSON pour Claude Code, texte brut pour Kilo, etc.).`;
         const finalPrompt = prompt + memoryInstructions;
-        const promptPath = path.join(agentsDir, `${name}.md`);
-        await fs.writeFile(promptPath, finalPrompt, 'utf-8');
         // Default mandatory environment variables according to user request
-        // SECURITY: Never default to placeholder tokens — require real env vars
         const authToken = process.env.ANTHROPIC_AUTH_TOKEN;
         if (!authToken) {
             return {
@@ -316,7 +578,6 @@ Tu es conçu pour être exécuté par différents runners (Claude, Kilo, Gemini,
         if (copyEnvFrom && projectRoot) {
             try {
                 const sourceSettingsPath = path.resolve(projectRoot, copyEnvFrom);
-                // Prevent path traversal: source must be inside projectRoot
                 if (!sourceSettingsPath.startsWith(path.resolve(projectRoot))) {
                     throw new Error(`copyEnvFrom path escapes project root: ${copyEnvFrom}`);
                 }
@@ -332,6 +593,63 @@ Tu es conçu pour être exécuté par différents runners (Claude, Kilo, Gemini,
             }
         }
         envVars.ANTHROPIC_MODEL = model; // Ensure model is correctly set
+        if (runner === 'hermes') {
+            const workspaceDir = getWorkspaceDir();
+            const hermesAgentDir = path.join(workspaceDir, '.overmind', 'hermes', `agent_${name}`);
+            const hermesSubDir = path.join(hermesAgentDir, '.hermes');
+            const hermesSkillsDir = path.join(hermesSubDir, 'skills');
+            await fs.mkdir(hermesSubDir, { recursive: true });
+            await fs.mkdir(hermesSkillsDir, { recursive: true });
+            const promptPath = path.join(hermesSubDir, 'SOUL.md');
+            await fs.writeFile(promptPath, finalPrompt, 'utf-8');
+            // Write .env
+            const envPath = path.join(hermesSubDir, '.env');
+            let envContent = '';
+            for (const [k, v] of Object.entries(envVars)) {
+                envContent += `${k}=${v}\n`;
+            }
+            await fs.writeFile(envPath, envContent, 'utf-8');
+            // Write config.yaml (MCP config)
+            const yamlPath = path.join(hermesSubDir, 'config.yaml');
+            let yamlContent = 'mcp_servers:\n';
+            const globalMcpPath = resolveConfigPath(CONFIG.CLAUDE.PATHS.MCP);
+            try {
+                const globalMcpContent = await fs.readFile(globalMcpPath, 'utf-8');
+                const globalMcp = JSON.parse(globalMcpContent);
+                mcpServers.forEach((serverName) => {
+                    if (globalMcp.mcpServers && globalMcp.mcpServers[serverName]) {
+                        const s = globalMcp.mcpServers[serverName];
+                        yamlContent += `  ${serverName}:\n`;
+                        if (s.url)
+                            yamlContent += `    url: "${s.url}"\n`;
+                        if (s.command)
+                            yamlContent += `    command: "${s.command}"\n`;
+                    }
+                });
+            }
+            catch {
+                // Ignored
+            }
+            await fs.writeFile(yamlPath, yamlContent, 'utf-8');
+            // Mémoriser la création de l'agent
+            try {
+                const memory = getMemoryProvider();
+                await memory.storeKnowledge({
+                    text: `Nouvel agent IA créé : '${name}'. Runner : hermes.`,
+                    source: 'agent',
+                    agentName: name,
+                });
+            }
+            catch {
+                // Ignored
+            }
+            return { promptPath, settingsPath: envPath };
+        }
+        const agentsDir = path.join(this.claudeDir, 'agents');
+        await fs.mkdir(this.claudeDir, { recursive: true });
+        await fs.mkdir(agentsDir, { recursive: true });
+        const promptPath = path.join(agentsDir, `${name}.md`);
+        await fs.writeFile(promptPath, finalPrompt, 'utf-8');
         const settings = {
             env: envVars,
             enableAllProjectMcpServers: false,
@@ -339,7 +657,6 @@ Tu es conçu pour être exécuté par différents runners (Claude, Kilo, Gemini,
             agent: name,
             runner: runner || 'claude',
         };
-        // Add runner specific metadata
         if (mode)
             settings.mode = mode;
         if (cliPath)
@@ -347,7 +664,6 @@ Tu es conçu pour être exécuté par différents runners (Claude, Kilo, Gemini,
         const settingsFileName = `settings_${name}.json`;
         const settingsPath = path.join(this.claudeDir, settingsFileName);
         await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
-        // 📂 ENSURE .mcp.<agent>.json CREATION
         try {
             const globalMcpPath = resolveConfigPath(CONFIG.CLAUDE.PATHS.MCP);
             const globalMcpContent = await fs.readFile(globalMcpPath, 'utf-8');
@@ -360,37 +676,36 @@ Tu es conçu pour être exécuté par différents runners (Claude, Kilo, Gemini,
             });
             const agentMcpPath = path.join(this.claudeDir, `.mcp.${name}.json`);
             await fs.writeFile(agentMcpPath, JSON.stringify({ mcpServers: agentMcpServers }, null, 2), 'utf-8');
-            console.error(`[AgentManager] ✅ .mcp.${name}.json created with ${Object.keys(agentMcpServers).length} servers.`);
         }
         catch (e) {
             console.error(`[AgentManager] ⚠️ Failed to create .mcp.${name}.json:`, e.message);
         }
-        // Mémoriser la création de l'agent dans Overmind
         try {
             const memory = getMemoryProvider();
             await memory.storeKnowledge({
-                text: `Nouvel agent IA créé : '${name}'.
-Runner : ${runner || 'claude'}.
-Modèle : ${model}.
-Capacités définies : ${prompt.slice(0, 300)}...
-Serveurs MCP activés : ${mcpServers.join(', ')}.`,
+                text: `Nouvel agent IA créé : '${name}'. Runner : ${runner || 'claude'}.`,
                 source: 'agent',
                 agentName: name,
             });
         }
         catch (_e) {
-            // Ignorer si la mémoire échoue
+            // Ignored
         }
         return { promptPath, settingsPath };
     }
     async getDetailedConfigs(name) {
         validateAgentName(name);
-        const agentsDir = path.join(this.claudeDir, 'agents');
-        const promptPath = path.join(agentsDir, `${name}.md`);
-        const settingsPath = path.join(this.claudeDir, `settings_${name}.json`);
-        const mcpPath = path.join(this.claudeDir, `.mcp.${name}.json`);
-        const skillPath = path.join(this.claudeDir, `agents/${name}_skill.md`);
-        const alternativeSkillPath = path.join(this.claudeDir, `skills/${name}.md`);
+        const workspaceDir = getWorkspaceDir();
+        const hermesAgentDir = path.join(workspaceDir, '.overmind', 'hermes', `agent_${name}`);
+        const hermesSubDir = path.join(hermesAgentDir, '.hermes');
+        let isHermes = false;
+        try {
+            const stat = await fs.stat(hermesAgentDir);
+            isHermes = stat.isDirectory();
+        }
+        catch {
+            // Ignored
+        }
         const result = {};
         const readFileSafe = async (filePath) => {
             try {
@@ -400,8 +715,69 @@ Serveurs MCP activés : ${mcpServers.join(', ')}.`,
                 return 'MISSING';
             }
         };
+        if (isHermes) {
+            result['prompt.md'] = await readFileSafe(path.join(hermesSubDir, 'SOUL.md'));
+            const envVars = {};
+            const envContent = await readFileSafe(path.join(hermesSubDir, '.env'));
+            if (envContent !== 'MISSING') {
+                envContent.split('\n').forEach((line) => {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#'))
+                        return;
+                    const eqIdx = trimmed.indexOf('=');
+                    if (eqIdx === -1)
+                        return;
+                    const k = trimmed.slice(0, eqIdx).trim();
+                    let v = trimmed.slice(eqIdx + 1).trim();
+                    if (v.startsWith('"') && v.endsWith('"'))
+                        v = v.slice(1, -1);
+                    else if (v.startsWith("'") && v.endsWith("'"))
+                        v = v.slice(1, -1);
+                    if (k)
+                        envVars[k] = v;
+                });
+            }
+            result['settings.json'] = JSON.stringify({
+                env: envVars,
+                model: envVars.MODEL || envVars.ANTHROPIC_MODEL || 'MiniMax-M2.7',
+                runner: 'hermes'
+            }, null, 2);
+            const mcpServers = {};
+            const yamlContent = await readFileSafe(path.join(hermesSubDir, 'config.yaml'));
+            if (yamlContent !== 'MISSING') {
+                const serverBlocks = yamlContent.split('\n  ');
+                serverBlocks.forEach((block) => {
+                    const lines = block.split('\n');
+                    const header = lines[0].trim();
+                    if (header && header.endsWith(':') && header !== 'mcp_servers:') {
+                        const srvName = header.slice(0, -1).trim();
+                        const srvObj = {};
+                        lines.slice(1).forEach((l) => {
+                            const parts = l.trim().split(':');
+                            if (parts.length >= 2) {
+                                const key = parts[0].trim();
+                                let val = parts.slice(1).join(':').trim();
+                                if (val.startsWith('"') && val.endsWith('"'))
+                                    val = val.slice(1, -1);
+                                srvObj[key] = val;
+                            }
+                        });
+                        mcpServers[srvName] = srvObj;
+                    }
+                });
+            }
+            result['.mcp.json'] = JSON.stringify({ mcpServers }, null, 2);
+            const skillPath = path.join(hermesSubDir, 'skills', 'skill.md');
+            result['skill.md'] = await readFileSafe(skillPath);
+            return result;
+        }
+        const agentsDir = path.join(this.claudeDir, 'agents');
+        const promptPath = path.join(agentsDir, `${name}.md`);
+        const settingsPath = path.join(this.claudeDir, `settings_${name}.json`);
+        const mcpPath = path.join(this.claudeDir, `.mcp.${name}.json`);
+        const skillPath = path.join(this.claudeDir, `agents/${name}_skill.md`);
+        const alternativeSkillPath = path.join(this.claudeDir, `skills/${name}.md`);
         // Fallback paths using workspace from OVERMIND_WORKSPACE env var
-        const workspaceDir = getWorkspaceDir();
         const fallbackAgentsDir = path.join(workspaceDir, '.overmind', 'agents');
         const fallbackPromptPath = path.join(fallbackAgentsDir, `${name}.md`);
         const fallbackSettingsDir = path.join(workspaceDir, '.overmind', 'agents', name);