@nomad-e/bluma-cli 0.0.109 → 0.0.110

package/dist/main.js

@@ -176,7 +176,8 @@ async function commandStatus(args) {
         error: `Command with id "${command_id}" not found. It may have expired or never existed.`
       };
     }
-    if (wait_seconds > 0 && entry.status === "running") {
+    const maxWait = Math.min(wait_seconds, 15);
+    if (maxWait > 0 && entry.status === "running") {
       await new Promise((resolve) => {
         const checkInterval = setInterval(() => {
           if (entry.status !== "running") {
@@ -187,7 +188,7 @@ async function commandStatus(args) {
         setTimeout(() => {
           clearInterval(checkInterval);
           resolve();
-        }, wait_seconds * 1e3);
+        }, maxWait * 1e3);
       });
     }
     let stdout = entry.stdout;
@@ -326,160 +327,6 @@ var init_async_command = __esm({
   }
 });
 
-// src/app/agent/core/llm/tool_call_normalizer.ts
-import { randomUUID } from "crypto";
-var ToolCallNormalizer;
-var init_tool_call_normalizer = __esm({
-  "src/app/agent/core/llm/tool_call_normalizer.ts"() {
-    "use strict";
-    ToolCallNormalizer = class {
-      /**
-       * Normaliza a mensagem do assistant, convertendo diferentes formatos de tool calls
-       */
-      static normalizeAssistantMessage(message) {
-        if (message.tool_calls && this.isOpenAIFormat(message.tool_calls)) {
-          return message;
-        }
-        const toolCalls = this.extractToolCalls(message);
-        if (toolCalls.length > 0) {
-          return {
-            role: message.role || "assistant",
-            content: message.content || null,
-            tool_calls: toolCalls
-          };
-        }
-        return message;
-      }
-      /**
-       * Verifica se já está no formato OpenAI
-       */
-      static isOpenAIFormat(toolCalls) {
-        if (!Array.isArray(toolCalls) || toolCalls.length === 0) return false;
-        const firstCall = toolCalls[0];
-        return typeof firstCall.id === "string" && firstCall.type === "function" && typeof firstCall.function?.name === "string" && typeof firstCall.function?.arguments === "string";
-      }
-      /**
-       * Extrai tool calls de diversos formatos possíveis
-       */
-      static extractToolCalls(message) {
-        const results = [];
-        if (message.tool_calls && Array.isArray(message.tool_calls)) {
-          for (const call of message.tool_calls) {
-            const normalized = this.normalizeToolCall(call);
-            if (normalized) results.push(normalized);
-          }
-        }
-        if (typeof message.content === "string" && message.content.trim()) {
-          const extracted = this.extractFromContent(message.content);
-          results.push(...extracted);
-        }
-        if (message.function_call) {
-          const normalized = this.normalizeToolCall(message.function_call);
-          if (normalized) results.push(normalized);
-        }
-        return results;
-      }
-      /**
-       * Normaliza um único tool call para o formato OpenAI
-       */
-      static normalizeToolCall(call) {
-        try {
-          if (call.id && call.function?.name) {
-            return {
-              id: call.id,
-              type: "function",
-              function: {
-                name: call.function.name,
-                arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments)
-              }
-            };
-          }
-          if (call.name) {
-            return {
-              id: call.id || randomUUID(),
-              type: "function",
-              function: {
-                name: call.name,
-                arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments || {})
-              }
-            };
-          }
-          if (call.function && typeof call.function === "object") {
-            return {
-              id: call.id || randomUUID(),
-              type: "function",
-              function: {
-                name: call.function.name,
-                arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments || {})
-              }
-            };
-          }
-          return null;
-        } catch (error) {
-          console.error("Error normalizing tool call:", error, call);
-          return null;
-        }
-      }
-      /**
-       * Extrai tool calls do content (pode estar em markdown, JSON, etc)
-       */
-      static extractFromContent(content) {
-        const results = [];
-        const cleanContent = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
-        const jsonMatches = this.extractJsonObjects(cleanContent);
-        for (const jsonStr of jsonMatches) {
-          try {
-            const parsed = JSON.parse(jsonStr);
-            if (Array.isArray(parsed)) {
-              for (const call of parsed) {
-                const normalized = this.normalizeToolCall(call);
-                if (normalized) results.push(normalized);
-              }
-            } else if (parsed.name || parsed.function) {
-              const normalized = this.normalizeToolCall(parsed);
-              if (normalized) results.push(normalized);
-            } else if (parsed.tool_calls && Array.isArray(parsed.tool_calls)) {
-              for (const call of parsed.tool_calls) {
-                const normalized = this.normalizeToolCall(call);
-                if (normalized) results.push(normalized);
-              }
-            }
-          } catch (e) {
-          }
-        }
-        return results;
-      }
-      /**
-       * Extrai objetos JSON de uma string (suporta múltiplos objetos)
-       */
-      static extractJsonObjects(text) {
-        const results = [];
-        let depth = 0;
-        let start = -1;
-        for (let i = 0; i < text.length; i++) {
-          if (text[i] === "{") {
-            if (depth === 0) start = i;
-            depth++;
-          } else if (text[i] === "}") {
-            depth--;
-            if (depth === 0 && start !== -1) {
-              results.push(text.substring(start, i + 1));
-              start = -1;
-            }
-          }
-        }
-        return results;
-      }
-      /**
-       * Valida se um tool call normalizado é válido
-       */
-      static isValidToolCall(call) {
-        return !!(call.id && call.type === "function" && call.function?.name && typeof call.function.arguments === "string");
-      }
-    };
-  }
-});
-
 // src/main.ts
 import React10 from "react";
 import { render } from "ink";
@@ -1635,10 +1482,9 @@ var ConfirmationPromptComponent = ({ toolCalls, preview, onDecision }) => {
 var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
-import OpenAI from "openai";
 import * as dotenv from "dotenv";
-import path15 from "path";
-import os8 from "os";
+import path16 from "path";
+import os9 from "os";
 
 // src/app/agent/tool_invoker.ts
 import { promises as fs8 } from "fs";
@@ -1987,20 +1833,20 @@ ${finalDiff}`,
 
 // src/app/agent/tools/natives/message.ts
 import { v4 as uuidv4 } from "uuid";
-function messageNotifyuser(args) {
-  const { message } = args;
-  const notification = {
-    type: "message_notify_user",
-    id: `notify_${uuidv4()}`,
+function message(args) {
+  const { content, message_type } = args;
+  const result = {
+    type: "message",
+    message_type,
+    id: `msg_${uuidv4()}`,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     content: {
-      format: "markdown",
-      body: message
+      body: content
     },
     success: true,
     delivered: true
   };
-  return Promise.resolve(notification);
+  return Promise.resolve(result);
 }
 
 // src/app/agent/tools/natives/ls.ts
@@ -2152,7 +1998,7 @@ import * as path5 from "path";
 var taskStore = [];
 var nextId = 1;
 function getTodoFilePath() {
-  return path5.join(process.cwd(), ".bluma", "todo.json");
+  return path5.join(process.cwd(), ".bluma-cli", "todo.json");
 }
 function loadTasksFromFile() {
   try {
@@ -2203,10 +2049,10 @@ function validateDescription(desc) {
   }
   return null;
 }
-function createResult(success, message) {
+function createResult(success, message2) {
   return {
     success,
-    message,
+    message: message2,
     tasks: taskStore,
     stats: calculateStats()
   };
@@ -3087,7 +2933,7 @@ var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
   const homeDir = os3.homedir();
-  const baseDir = path9.join(homeDir, ".bluma", "artifacts");
+  const baseDir = path9.join(homeDir, ".bluma-cli", "artifacts");
   const sessionId2 = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
   artifactsDir = path9.join(baseDir, sessionId2);
   await fs7.mkdir(artifactsDir, { recursive: true });
@@ -3409,6 +3255,44 @@ async function searchWeb(args) {
   }
 }
 
+// src/app/agent/tools/natives/load_skill.ts
+var globalContext = null;
+function initializeSkillContext(ctx) {
+  globalContext = ctx;
+}
+async function loadSkill(args) {
+  const { skill_name } = args;
+  if (!skill_name || typeof skill_name !== "string") {
+    return {
+      success: false,
+      message: "skill_name is required"
+    };
+  }
+  if (!globalContext?.skillLoader) {
+    return {
+      success: false,
+      message: "Skill system not initialized. No skills available."
+    };
+  }
+  const skill = globalContext.skillLoader.load(skill_name);
+  if (!skill) {
+    const available = globalContext.skillLoader.listAvailable();
+    const availableNames = available.map((s) => s.name).join(", ") || "none";
+    return {
+      success: false,
+      message: `Skill "${skill_name}" not found. Available skills: ${availableNames}`
+    };
+  }
+  return {
+    success: true,
+    message: `Skill "${skill_name}" loaded. Follow these instructions:
+
+${skill.content}`,
+    skill_name: skill.name,
+    description: skill.description
+  };
+}
+
 // src/app/agent/tool_invoker.ts
 var ToolInvoker = class {
   // Mapa privado para associar nomes de ferramentas às suas funções de implementação.
@@ -3452,13 +3336,13 @@ var ToolInvoker = class {
     this.toolImplementations.set("command_status", commandStatus);
     this.toolImplementations.set("send_command_input", sendCommandInput);
     this.toolImplementations.set("kill_command", killCommand);
-    this.toolImplementations.set("message_notify_user", messageNotifyuser);
+    this.toolImplementations.set("message", message);
     this.toolImplementations.set("todo", todo);
     this.toolImplementations.set("task_boundary", taskBoundary);
     this.toolImplementations.set("create_artifact", createArtifact);
     this.toolImplementations.set("read_artifact", readArtifact);
     this.toolImplementations.set("search_web", searchWeb);
-    this.toolImplementations.set("agent_end_turn", async () => ({ success: true, message: "Task ended by agent." }));
+    this.toolImplementations.set("load_skill", loadSkill);
   }
   /**
    * Retorna a lista de definições de todas as ferramentas nativas carregadas.
@@ -3688,7 +3572,7 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path14 from "path";
+import path15 from "path";
 
 // src/app/agent/session_manager/session_manager.ts
 import path12 from "path";
@@ -3854,10 +3738,180 @@ async function saveSessionHistory(sessionFile, history) {
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
-import os6 from "os";
+import os7 from "os";
+import fs12 from "fs";
+import path14 from "path";
+import { execSync } from "child_process";
+
+// src/app/agent/skills/skill_loader.ts
 import fs11 from "fs";
 import path13 from "path";
-import { execSync } from "child_process";
+import os6 from "os";
+var SkillLoader = class {
+  projectSkillsDir;
+  globalSkillsDir;
+  cache = /* @__PURE__ */ new Map();
+  constructor(projectRoot) {
+    this.projectSkillsDir = path13.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path13.join(os6.homedir(), ".bluma", "skills");
+  }
+  /**
+   * Lista skills disponíveis de ambas as fontes
+   * Skills de projeto têm prioridade sobre globais com mesmo nome
+   */
+  listAvailable() {
+    const skills = /* @__PURE__ */ new Map();
+    const globalSkills = this.listFromDir(this.globalSkillsDir, "global");
+    for (const skill of globalSkills) {
+      skills.set(skill.name, skill);
+    }
+    const projectSkills = this.listFromDir(this.projectSkillsDir, "project");
+    for (const skill of projectSkills) {
+      skills.set(skill.name, skill);
+    }
+    return Array.from(skills.values());
+  }
+  /**
+   * Lista skills de um diretório específico
+   */
+  listFromDir(dir, source) {
+    if (!fs11.existsSync(dir)) return [];
+    try {
+      return fs11.readdirSync(dir).filter((d) => {
+        const fullPath = path13.join(dir, d);
+        return fs11.statSync(fullPath).isDirectory() && fs11.existsSync(path13.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path13.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Carrega metadata de um path específico
+   */
+  loadMetadataFromPath(skillPath, skillName, source) {
+    if (!fs11.existsSync(skillPath)) return null;
+    try {
+      const raw = fs11.readFileSync(skillPath, "utf-8");
+      const parsed = this.parseFrontmatter(raw);
+      return {
+        name: parsed.name || skillName,
+        description: parsed.description || "",
+        source,
+        version: parsed.version,
+        author: parsed.author,
+        license: parsed.license
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Carrega skill completa - procura primeiro em projeto, depois global
+   */
+  load(name) {
+    if (this.cache.has(name)) return this.cache.get(name);
+    const projectPath = path13.join(this.projectSkillsDir, name, "SKILL.md");
+    if (fs11.existsSync(projectPath)) {
+      const skill = this.loadFromPath(projectPath, name, "project");
+      if (skill) {
+        this.cache.set(name, skill);
+        return skill;
+      }
+    }
+    const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
+    if (fs11.existsSync(globalPath)) {
+      const skill = this.loadFromPath(globalPath, name, "global");
+      if (skill) {
+        this.cache.set(name, skill);
+        return skill;
+      }
+    }
+    return null;
+  }
+  /**
+   * Carrega skill de um path específico
+   */
+  loadFromPath(skillPath, name, source) {
+    try {
+      const raw = fs11.readFileSync(skillPath, "utf-8");
+      const parsed = this.parseFrontmatter(raw);
+      return {
+        name: parsed.name || name,
+        description: parsed.description || "",
+        content: parsed.content.trim(),
+        source,
+        version: parsed.version,
+        author: parsed.author,
+        license: parsed.license
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Parse simples de YAML frontmatter
+   */
+  parseFrontmatter(raw) {
+    const lines = raw.split("\n");
+    if (lines[0]?.trim() !== "---") {
+      return { content: raw };
+    }
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.trim() === "---") {
+        endIndex = i;
+        break;
+      }
+    }
+    if (endIndex === -1) {
+      return { content: raw };
+    }
+    const frontmatter = {};
+    for (let i = 1; i < endIndex; i++) {
+      const line = lines[i];
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim();
+        const value = line.slice(colonIndex + 1).trim();
+        frontmatter[key] = value;
+      }
+    }
+    const content = lines.slice(endIndex + 1).join("\n");
+    return {
+      name: frontmatter["name"],
+      description: frontmatter["description"],
+      version: frontmatter["version"],
+      author: frontmatter["author"],
+      license: frontmatter["license"],
+      content
+    };
+  }
+  /**
+   * Limpa o cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Verifica se uma skill existe (em projeto ou global)
+   */
+  exists(name) {
+    const projectPath = path13.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs11.existsSync(projectPath) || fs11.existsSync(globalPath);
+  }
+  /**
+   * Retorna os diretórios de skills
+   */
+  getSkillsDirs() {
+    return {
+      project: this.projectSkillsDir,
+      global: this.globalSkillsDir
+    };
+  }
+};
+
+// src/app/agent/core/prompt/prompt_builder.ts
 function getNodeVersion() {
   try {
     return process.version;
@@ -3885,10 +3939,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs11.existsSync(path13.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs11.existsSync(path13.join(dir, "yarn.lock"))) return "yarn";
-    if (fs11.existsSync(path13.join(dir, "bun.lockb"))) return "bun";
-    if (fs11.existsSync(path13.join(dir, "package-lock.json"))) return "npm";
+    if (fs12.existsSync(path14.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs12.existsSync(path14.join(dir, "yarn.lock"))) return "yarn";
+    if (fs12.existsSync(path14.join(dir, "bun.lockb"))) return "bun";
+    if (fs12.existsSync(path14.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -3896,9 +3950,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs11.readdirSync(dir);
+    const files = fs12.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs11.readFileSync(path13.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs12.readFileSync(path14.join(dir, "package.json"), "utf-8"));
       if (pkg.dependencies?.next || pkg.devDependencies?.next) return "Next.js";
       if (pkg.dependencies?.react || pkg.devDependencies?.react) return "React";
       if (pkg.dependencies?.express || pkg.devDependencies?.express) return "Express";
@@ -3917,9 +3971,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path13.join(dir, "package.json");
-    if (fs11.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path14.join(dir, "package.json");
+    if (fs12.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -3928,7 +3982,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs11.existsSync(path13.join(dir, "pytest.ini")) || fs11.existsSync(path13.join(dir, "conftest.py"))) return "pytest";
+    if (fs12.existsSync(path14.join(dir, "pytest.ini")) || fs12.existsSync(path14.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -3936,9 +3990,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path13.join(dir, "package.json");
-    if (fs11.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path14.join(dir, "package.json");
+    if (fs12.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -4006,7 +4060,7 @@ You MUST adapt all commands to this environment. Use the correct package manager
 ## How You Work
 
 ### For Multi-Step Tasks:
-1. **Acknowledge** - Confirm the request immediately via message_notify_user
+1. **Acknowledge** - Confirm the request immediately via message
 2. **Plan** - Use the TODO tool to create a structured plan
 3. **Execute** - Implement with clear narration of each step
 4. **Test** - Run tests after any code changes (MANDATORY for production code)
@@ -4017,25 +4071,11 @@ You MUST adapt all commands to this environment. Use the correct package manager
 - Quick acknowledgment + immediate action
 - No TODO needed for single operations
 
-### Testing Philosophy (CRITICAL):
-You are a **teammate who writes tests**, not an assistant who skips them.
-
-**ALWAYS run tests when:**
-- You modify any function or module
-- You add new functionality
-- You fix a bug (write a regression test first)
-- The user asks for a feature
-
-**Test workflow:**
-1. Before editing: Run existing tests to ensure baseline passes
-2. After editing: Run tests to verify nothing broke
-3. For new features: Write tests alongside implementation
-4. For bugs: Write failing test \u2192 fix \u2192 verify test passes
+### Testing Philosophy:
+Run tests when modifying code. Use the \`testing\` skill for detailed best practices.
 
-**Commands you should know:**
+**Commands:**
 - Run tests: {test_command}
-- Run single test: Check project conventions
-- Watch mode: Usually \`npm run test:watch\` or \`npm test -- --watch\`
 </workflow>
 
 ---
@@ -4050,8 +4090,8 @@ You are a **teammate who writes tests**, not an assistant who skips them.
 - **Check file exists** before attempting edits
 
 ### Safe Auto-Approved Tools (no confirmation needed):
-- message_notify_user
-- ls_tool
+- message
+- ls_tool 
 - read_file_lines
 - count_file_lines
 - todo
@@ -4102,7 +4142,7 @@ You MUST use \`command_status\` to get the output.
 [Step 2] command_status({ command_id: "cmd_001", wait_seconds: 120 })
 \u2192 { status: "completed", exit_code: 0, stdout: "added 150 packages..." }
 
-[Step 3] message_notify_user("Dependencies installed successfully.")
+[Step 3] message({ content: "Dependencies installed.", message_type: "info" })
 \`\`\`
 
 **[OK] Run tests:**
@@ -4131,7 +4171,7 @@ You MUST use \`command_status\` to get the output.
 [Step 2] command_status({ command_id: "cmd_004", wait_seconds: 10 })
 \u2192 { status: "running" }
 
-[Step 3] message_notify_user("Building Docker image, please wait...")
+[Step 3] message({ content: "Building Docker image...", message_type: "info" })
 
 [Step 4] command_status({ command_id: "cmd_004", wait_seconds: 10 })
 \u2192 { status: "completed", exit_code: 0, stdout: "Successfully built abc123" }
@@ -4140,7 +4180,7 @@ You MUST use \`command_status\` to get the output.
 **[WRONG] Never forget command_status:**
 \`\`\`
 shell_command({ command: "npm install" })
-message_notify_user("Installed!") // WRONG: You don't know if it succeeded!
+message({ content: "Installed!", message_type: "info" }) // WRONG: You don't know if it succeeded!
 \`\`\`
 
 **[WRONG] Never use long waits (blocks user):**
@@ -4185,39 +4225,29 @@ Examples:
 - Celebrate wins, acknowledge mistakes
 
 **Message via tool only:**
-- Use message_notify_user for ALL communication
-- Never assume the user sees internal state
-- Report progress proactively
+- message with \`result\` = END your turn (after questions/completions)
+- message with \`info\` = progress update, you continue working
 
-**Example flow:**
+**CRITICAL: After asking questions, ALWAYS use result!**
+
+**Asking question (result):**
 \`\`\`
-message_notify_user("Alex, understood. Adding the auth middleware. Let me check the current implementation first.")
-[uses read_file_lines]
-message_notify_user("Found the router at /src/routes/index.ts. I'll add the middleware before the protected routes.")
-[uses edit_tool]
-message_notify_user("Done. Running tests to verify...")
-[uses shell_command with {test_command}]
-message_notify_user("All 47 tests pass. The middleware is working correctly.")
+message({ content: "Project or global?", message_type: "result" })
+// STOP and wait for user
 \`\`\`
-</communication_style>
-
----
-
-<git_guidelines>
-## Git Best Practices
 
-When in a git repository:
-- **Review changes**: \`git diff HEAD\` before any commit
-- **Commit format**: Conventional Commits (feat:, fix:, chore:, docs:, test:, refactor:)
-- **NEVER push** unless explicitly asked
-- **NEVER use destructive commands**: reset --hard, rebase -i, force push
+**Progress then continue (info):**
+\`\`\`
+message({ content: "Installing...", message_type: "info" })
+// continue with next tool
+\`\`\`
 
-Good commit messages:
-- feat: add user authentication middleware
-- fix: resolve race condition in payment processing
-- test: add unit tests for auth module
-- chore: update dependencies
-</git_guidelines>
+**Task done (result):**
+\`\`\`
+message({ content: "Done. All tests pass.", message_type: "result" })
+// STOP - finished
+\`\`\`
+</communication_style>
 
 ---
 
@@ -4254,15 +4284,15 @@ You communicate because you respect your teammate.
 Let's build something great, {username}.
 </personality>
 `;
-function getUnifiedSystemPrompt() {
+function getUnifiedSystemPrompt(availableSkills) {
   const cwd = process.cwd();
   const env = {
-    os_type: os6.type(),
-    os_version: os6.release(),
-    architecture: os6.arch(),
+    os_type: os7.type(),
+    os_version: os7.release(),
+    architecture: os7.arch(),
     workdir: cwd,
     shell_type: process.env.SHELL || process.env.COMSPEC || "unknown",
-    username: os6.userInfo().username,
+    username: os7.userInfo().username,
     current_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     is_git_repo: isGitRepo(cwd) ? "yes" : "no",
@@ -4274,15 +4304,164 @@ function getUnifiedSystemPrompt() {
     test_framework: getTestFramework(cwd),
     test_command: getTestCommand(cwd)
   };
-  return Object.entries(env).reduce(
-    (prompt, [key, value]) => prompt.replaceAll(`{${key}}`, value),
+  let prompt = Object.entries(env).reduce(
+    (p, [key, value]) => p.replaceAll(`{${key}}`, value),
     SYSTEM_PROMPT
   );
+  if (availableSkills && availableSkills.length > 0) {
+    const skillsList = availableSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+    prompt += `
+
+---
+
+<available_skills>
+## Specialized Skills
+
+You have access to specialized knowledge modules called **skills**. Skills extend your capabilities with domain-specific expertise, workflows, and best practices.
+
+**Available skills:**
+${skillsList}
+
+---
+
+### Skill Selection Process
+
+**BEFORE starting any task, follow this decision process:**
+
+1. **Understand the task** - What is the user trying to accomplish?
+2. **Identify the domain** - What area of expertise does this task require? (e.g., version control, testing, deployment, documentation)
+3. **Match against skills** - Read each skill's description above. Does any skill's domain match the task?
+4. **Load if matched** - If a skill matches, load it FIRST with \`load_skill\` before taking any action
+5. **Follow skill instructions** - Once loaded, the skill provides specific workflows to follow
+
+**Decision examples:**
+\`\`\`
+Task: "Save my changes with a good message"
+\u2192 Domain: Version control, commits
+\u2192 Check skills: Is there a skill for git/commits/version control?
+\u2192 If yes: load_skill({ skill_name: "<matching-skill>" })
+
+Task: "Make sure this code works correctly"
+\u2192 Domain: Testing, validation, quality assurance
+\u2192 Check skills: Is there a skill for testing?
+\u2192 If yes: load_skill({ skill_name: "<matching-skill>" })
+
+Task: "Release this to users"
+\u2192 Domain: Publishing, deployment, release
+\u2192 Check skills: Is there a skill for publishing/releasing?
+\u2192 If yes: load_skill({ skill_name: "<matching-skill>" })
+\`\`\`
+
+**Key principle:** Match the TASK DOMAIN to the SKILL DESCRIPTION, not specific words.
+
+---
+
+### Skill Interpretation Rules (CRITICAL)
+
+When you load a skill with \`load_skill\`, you receive a SKILL.md file. **ALWAYS read the YAML frontmatter header FIRST** before reading the body.
+
+**Frontmatter Structure:**
+\`\`\`yaml
+---
+# IDENTITY
+name: skill-name           # Unique identifier
+description: ...           # Purpose of the skill
+version: 1.0.0
+author: ...
+license: ...
+
+# DEPENDENCIES
+depends_on:                # Other skills this skill may delegate to
+  - other-skill-name
+
+# TOOLS
+tools:
+  required:                # Tools you MUST use for this skill
+    - shell_command
+    - command_status
+  recommended:             # Tools that enhance execution
+    - read_file_lines
+---
+\`\`\`
+
+**Interpretation Flow:**
+\`\`\`
+1. LOAD SKILL
+   load_skill({ skill_name: "npm-publish" })
+
+2. READ FRONTMATTER FIRST
+   - name: npm-publish
+   - depends_on: [git-conventional]
+   - tools.required: [shell_command, command_status]
+   - tools.recommended: [read_file_lines, message]
+
+3. VERIFY TOOLS
+   Are required tools available? If not, inform user.
+
+4. READ SKILL BODY
+   Workflow instructions, examples, rules
+
+5. EXECUTE WORKFLOW
+   - Use the REQUIRED tools from frontmatter
+   - When body says "delegate to X":
+     a. Verify X is in depends_on
+     b. load_skill({ skill_name: "X" })
+     c. Execute X workflow
+     d. Return to primary skill
+   - Continue until workflow complete
+\`\`\`
+
+**Field Meanings:**
+| Field | Purpose | Your Action |
+|-------|---------|-------------|
+| \`name\` | Skill identifier | Confirm correct skill loaded |
+| \`description\` | Skill purpose | Understand what this skill does |
+| \`depends_on\` | Skill dependencies | Know which skills can be delegated to |
+| \`tools.required\` | Mandatory tools | MUST use these tools for execution |
+| \`tools.recommended\` | Optional tools | Use if helpful |
+
+**Orchestration Example:**
+\`\`\`
+User: "Publish the package"
+
+1. Match domain -> npm-publish skill
+2. load_skill({ skill_name: "npm-publish" })
+
+3. Read frontmatter:
+   - depends_on: [git-conventional]
+   - tools.required: [shell_command, command_status]
+
+4. Read body -> Workflow says:
+   "Step 1: If uncommitted changes, delegate to git-conventional"
+
+5. Check git status with shell_command (required tool)
+   Found changes
+
+6. Delegate: load_skill({ skill_name: "git-conventional" })
+   - Read git-conventional frontmatter
+   - Follow its workflow for commit
+   - Commit done
+
+7. Return to npm-publish Step 2: npm version patch
+8. Step 3: npm publish
+9. Done
+\`\`\`
+
+**Rules:**
+- Frontmatter is the SPECIFICATION - read it first
+- Body is the WORKFLOW - execute after understanding spec
+- \`depends_on\` authorizes delegation - only delegate to listed skills
+- \`tools.required\` are mandatory - use them for execution
+- The skill body tells you WHEN to delegate, not the frontmatter
+</available_skills>
+`;
+  }
+  return prompt;
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path13.join(dir, ".git");
-    return fs11.existsSync(gitPath) && fs11.lstatSync(gitPath).isDirectory();
+    const gitPath = path14.join(dir, ".git");
+    return fs12.existsSync(gitPath) && fs12.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -4338,8 +4517,155 @@ function createApiContextWindow(fullHistory, maxTurns) {
   return finalContext;
 }
 
+// src/app/agent/core/llm/tool_call_normalizer.ts
+import { randomUUID } from "crypto";
+var ToolCallNormalizer = class {
+  /**
+   * Normaliza a mensagem do assistant, convertendo diferentes formatos de tool calls
+   */
+  static normalizeAssistantMessage(message2) {
+    if (message2.tool_calls && this.isOpenAIFormat(message2.tool_calls)) {
+      return message2;
+    }
+    const toolCalls = this.extractToolCalls(message2);
+    if (toolCalls.length > 0) {
+      return {
+        role: message2.role || "assistant",
+        content: message2.content || null,
+        tool_calls: toolCalls
+      };
+    }
+    return message2;
+  }
+  /**
+   * Verifica se já está no formato OpenAI
+   */
+  static isOpenAIFormat(toolCalls) {
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0) return false;
+    const firstCall = toolCalls[0];
+    return typeof firstCall.id === "string" && firstCall.type === "function" && typeof firstCall.function?.name === "string" && typeof firstCall.function?.arguments === "string";
+  }
+  /**
+   * Extrai tool calls de diversos formatos possíveis
+   */
+  static extractToolCalls(message2) {
+    const results = [];
+    if (message2.tool_calls && Array.isArray(message2.tool_calls)) {
+      for (const call of message2.tool_calls) {
+        const normalized = this.normalizeToolCall(call);
+        if (normalized) results.push(normalized);
+      }
+    }
+    if (typeof message2.content === "string" && message2.content.trim()) {
+      const extracted = this.extractFromContent(message2.content);
+      results.push(...extracted);
+    }
+    if (message2.function_call) {
+      const normalized = this.normalizeToolCall(message2.function_call);
+      if (normalized) results.push(normalized);
+    }
+    return results;
+  }
+  /**
+   * Normaliza um único tool call para o formato OpenAI
+   */
+  static normalizeToolCall(call) {
+    try {
+      if (call.id && call.function?.name) {
+        return {
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.function.name,
+            arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments)
+          }
+        };
+      }
+      if (call.name) {
+        return {
+          id: call.id || randomUUID(),
+          type: "function",
+          function: {
+            name: call.name,
+            arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments || {})
+          }
+        };
+      }
+      if (call.function && typeof call.function === "object") {
+        return {
+          id: call.id || randomUUID(),
+          type: "function",
+          function: {
+            name: call.function.name,
+            arguments: typeof call.function.arguments === "string" ? call.function.arguments : JSON.stringify(call.function.arguments || {})
+          }
+        };
+      }
+      return null;
+    } catch (error) {
+      console.error("Error normalizing tool call:", error, call);
+      return null;
+    }
+  }
+  /**
+   * Extrai tool calls do content (pode estar em markdown, JSON, etc)
+   */
+  static extractFromContent(content) {
+    const results = [];
+    const cleanContent = content.replace(/```(?:json)?\s*([\s\S]*?)```/g, "$1");
+    const jsonMatches = this.extractJsonObjects(cleanContent);
+    for (const jsonStr of jsonMatches) {
+      try {
+        const parsed = JSON.parse(jsonStr);
+        if (Array.isArray(parsed)) {
+          for (const call of parsed) {
+            const normalized = this.normalizeToolCall(call);
+            if (normalized) results.push(normalized);
+          }
+        } else if (parsed.name || parsed.function) {
+          const normalized = this.normalizeToolCall(parsed);
+          if (normalized) results.push(normalized);
+        } else if (parsed.tool_calls && Array.isArray(parsed.tool_calls)) {
+          for (const call of parsed.tool_calls) {
+            const normalized = this.normalizeToolCall(call);
+            if (normalized) results.push(normalized);
+          }
+        }
+      } catch (e) {
+      }
+    }
+    return results;
+  }
+  /**
+   * Extrai objetos JSON de uma string (suporta múltiplos objetos)
+   */
+  static extractJsonObjects(text) {
+    const results = [];
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === "{") {
+        if (depth === 0) start = i;
+        depth++;
+      } else if (text[i] === "}") {
+        depth--;
+        if (depth === 0 && start !== -1) {
+          results.push(text.substring(start, i + 1));
+          start = -1;
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Valida se um tool call normalizado é válido
+   */
+  static isValidToolCall(call) {
+    return !!(call.id && call.type === "function" && call.function?.name && typeof call.function.arguments === "string");
+  }
+};
+
 // src/app/agent/bluma/core/bluma.ts
-init_tool_call_normalizer();
 var BluMaAgent = class {
   llm;
   deploymentName;
@@ -4349,6 +4675,7 @@ var BluMaAgent = class {
   eventBus;
   mcpClient;
   feedbackSystem;
+  skillLoader;
   maxContextTurns = 30;
   isInterrupted = false;
   constructor(sessionId2, eventBus2, llm, deploymentName, mcpClient, feedbackSystem) {
@@ -4358,6 +4685,7 @@ var BluMaAgent = class {
     this.deploymentName = deploymentName;
     this.mcpClient = mcpClient;
     this.feedbackSystem = feedbackSystem;
+    this.skillLoader = new SkillLoader(process.cwd());
     this.eventBus.on("user_interrupt", () => {
       this.isInterrupted = true;
       this.eventBus.emit("backend_message", { type: "done", status: "interrupted" });
@@ -4369,6 +4697,10 @@ var BluMaAgent = class {
       try {
         if (this.sessionFile) {
           await saveSessionHistory(this.sessionFile, this.history);
+        } else {
+          const [sessionFile, _] = await loadOrcreateSession(this.sessionId);
+          this.sessionFile = sessionFile;
+          await saveSessionHistory(this.sessionFile, this.history);
         }
       } catch (e) {
         this.eventBus.emit("backend_message", { type: "error", message: `Falha ao salvar hist\xF3rico ap\xF3s user_overlay: ${e.message}` });
@@ -4381,8 +4713,13 @@ var BluMaAgent = class {
     const [sessionFile, history] = await loadOrcreateSession(this.sessionId);
     this.sessionFile = sessionFile;
     this.history = history;
+    initializeSkillContext({
+      history: this.history,
+      skillLoader: this.skillLoader
+    });
     if (this.history.length === 0) {
-      const systemPrompt = getUnifiedSystemPrompt();
+      const availableSkills = this.skillLoader.listAvailable();
+      const systemPrompt = getUnifiedSystemPrompt(availableSkills);
       this.history.push({ role: "system", content: systemPrompt });
       await saveSessionHistory(this.sessionFile, this.history);
     }
@@ -4397,6 +4734,9 @@ var BluMaAgent = class {
     this.isInterrupted = false;
     const inputText = String(userInput.content || "").trim();
     this.history.push({ role: "user", content: inputText });
+    if (inputText === "/init") {
+      this.eventBus.emit("dispatch", inputText);
+    }
     await this._continueConversation();
   }
   async handleToolResponse(decisionData) {
@@ -4495,9 +4835,15 @@ var BluMaAgent = class {
         });
       }
       this.eventBus.emit("backend_message", { type: "tool_result", tool_name: toolName, result: toolResultContent });
-      if (toolName.includes("agent_end_turn")) {
-        shouldContinueConversation = false;
-        this.eventBus.emit("backend_message", { type: "done", status: "completed" });
+      if (toolName === "message") {
+        try {
+          const resultObj = typeof toolResultContent === "string" ? JSON.parse(toolResultContent) : toolResultContent;
+          if (resultObj.message_type === "result") {
+            shouldContinueConversation = false;
+            this.eventBus.emit("backend_message", { type: "done", status: "completed" });
+          }
+        } catch {
+        }
       }
     } else {
       toolResultContent = "The system rejected this action. Verify that the command you are executing contributes to the tasks intent and try again.";
@@ -4524,7 +4870,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path14.basename(toolArgs.file_path);
+      const filename = path15.basename(toolArgs.file_path);
       return createDiff(filename, editData.currentContent || "", editData.newContent);
     } catch (e) {
       return `An unexpected error occurred while generating the edit preview: ${e.message}`;
@@ -4550,18 +4896,18 @@ ${editData.error.display}`;
         this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
         return;
       }
-      let message = response.choices[0].message;
-      message = ToolCallNormalizer.normalizeAssistantMessage(message);
-      if (message.reasoning_content || message.reasoning) {
-        const reasoningText = message.reasoning_content || message.reasoning;
+      let message2 = response.choices[0].message;
+      message2 = ToolCallNormalizer.normalizeAssistantMessage(message2);
+      if (message2.reasoning_content || message2.reasoning) {
+        const reasoningText = message2.reasoning_content || message2.reasoning;
         this.eventBus.emit("backend_message", {
           type: "reasoning",
           content: typeof reasoningText === "string" ? reasoningText : JSON.stringify(reasoningText)
         });
       }
-      this.history.push(message);
-      if (message.tool_calls && message.tool_calls.length > 0) {
-        const validToolCalls = message.tool_calls.filter(
+      this.history.push(message2);
+      if (message2.tool_calls && message2.tool_calls.length > 0) {
+        const validToolCalls = message2.tool_calls.filter(
           (call) => ToolCallNormalizer.isValidToolCall(call)
         );
         if (validToolCalls.length === 0) {
@@ -4573,12 +4919,12 @@ ${editData.error.display}`;
           return;
         }
         const autoApprovedTools = [
-          "agent_end_turn",
-          "message_notify_user",
+          "message",
           "ls_tool",
           "count_file_lines",
           "read_file_lines",
-          "todo"
+          "todo",
+          "load_skill"
         ];
         const toolToCall = validToolCalls[0];
         const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
@@ -4594,13 +4940,13 @@ ${editData.error.display}`;
             this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls });
           }
         }
-      } else if (message.content) {
-        this.eventBus.emit("backend_message", { type: "assistant_message", content: message.content });
+      } else if (message2.content) {
+        this.eventBus.emit("backend_message", { type: "assistant_message", content: message2.content });
         const feedback = this.feedbackSystem.generateFeedback({
           event: "protocol_violation_direct_text",
-          details: { violationContent: message.content }
+          details: { violationContent: message2.content }
         });
-        this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: message.content });
+        this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: message2.content });
         this.history.push({ role: "system", content: feedback.correction });
         await this._continueConversation();
       } else {
@@ -4617,14 +4963,20 @@ ${editData.error.display}`;
 };
 
 // src/app/agent/core/llm/llm.ts
-var OpenAIAdapter = class {
+import OpenAI from "openai";
+var LLMService = class {
   client;
-  constructor(client) {
-    this.client = client;
+  defaultModel;
+  constructor(config2) {
+    this.client = new OpenAI({
+      apiKey: config2.apiKey,
+      baseURL: config2.baseUrl || "http://109.51.171.144/mistrall/v1"
+    });
+    this.defaultModel = config2.model || "";
   }
   async chatCompletion(params) {
     const resp = await this.client.chat.completions.create({
-      model: params.model,
+      model: params.model || this.defaultModel,
       messages: params.messages,
       tools: params.tools,
       tool_choice: params.tool_choice,
@@ -4634,6 +4986,12 @@ var OpenAIAdapter = class {
     });
     return resp;
   }
+  /**
+   * Retorna o modelo padrão configurado
+   */
+  getDefaultModel() {
+    return this.defaultModel;
+  }
 };
 
 // src/app/agent/subagents/registry.ts
@@ -4648,7 +5006,7 @@ function getSubAgentByCommand(cmd) {
 }
 
 // src/app/agent/subagents/init/init_system_prompt.ts
-import os7 from "os";
+import os8 from "os";
 var SYSTEM_PROMPT2 = `
 
 ### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -4662,7 +5020,7 @@ You extend the BluMa multi-agent architecture and handle the project bootstrappi
   You are BluMa InitSubAgent. Maintain professionalism and technical language.
 
 - Communication:
-  ALL messages must be sent via 'message_notify_user'.
+  ALL messages must be sent via 'message'.
   No direct text replies to the user.
 
 - Task Completion:
@@ -4787,8 +5145,8 @@ Rule Summary:
 - Never invent file content. Read files via tools to confirm.
 
 ## OUTPUT
-- Emit 'backend_message' events through tools only (message_notify_user) for progress updates.
-- Before writing BluMa.md, propose structure via message_notify_user and proceed using edit_tool.
+- Emit 'backend_message' events through tools only (message) for progress updates.
+- Before writing BluMa.md, propose structure via message and proceed using edit_tool.
 - If an irreversible operation is needed (e.g., overwriting an existing BluMa.md), issue 'confirmation_request' unless user policy indicates auto-approval.
 - Never send or present draft versions of BluMa.md. Only produce and deliver the final, validated BluMa.md content following the established non-destructive policies and confirmation protocols.
 - On successful generation of BluMa.md, emit 'done' with status 'completed' and call agent_end_turn.
@@ -4802,7 +5160,7 @@ Rule Summary:
 ## EXEMPLAR FLOW (GUIDELINE)
 1) Explore repo: ls + targeted readLines for key files (package.json, tsconfig.json, README, etc.)
 2) Synthesize stack and structure with citations of evidence (file paths) in the notebook
-3) Draft BluMa.md structure (message_notify_user)
+3) Draft BluMa.md structure (message)
 4) Write BluMa.md via edit_tool
 5) Announce completion and agent_end_turn
 
@@ -4811,12 +5169,12 @@ Rule Summary:
 function getInitPrompt() {
   const now = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os7.type(),
-    os_version: os7.release(),
-    architecture: os7.arch(),
+    os_type: os8.type(),
+    os_version: os8.release(),
+    architecture: os8.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os7.userInfo().username || "Unknown",
+    username: os8.userInfo().username || "Unknown",
     current_date: now.toISOString().split("T")[0],
     // Formato YYYY-MM-DD
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
@@ -4907,17 +5265,17 @@ ${editData.error.display}`;
         this.emitEvent("info", { message: "SubAgent task cancelled byuserr." });
         return;
       }
-      const message = response.choices[0].message;
-      this.history.push(message);
-      if (message.tool_calls) {
-        await this._handleToolExecution({ type: "user_decision_execute", tool_calls: message.tool_calls });
-        const lastToolName = message.tool_calls[0].function.name;
+      const message2 = response.choices[0].message;
+      this.history.push(message2);
+      if (message2.tool_calls) {
+        await this._handleToolExecution({ type: "user_decision_execute", tool_calls: message2.tool_calls });
+        const lastToolName = message2.tool_calls[0].function.name;
         if (!lastToolName.includes("agent_end_turn") && !this.isInterrupted) {
           await this._continueConversation();
         }
-      } else if (message.content) {
-        this.emitEvent("assistant_message", { content: message.content });
-        this.emitEvent("protocol_violation", { message: "Direct text emission detected from subagent.", content: message.content });
+      } else if (message2.content) {
+        this.emitEvent("assistant_message", { content: message2.content });
+        this.emitEvent("protocol_violation", { message: "Direct text emission detected from subagent.", content: message2.content });
       } else {
         this.emitEvent("info", { message: "SubAgent is thinking... continuing reasoning cycle." });
       }
@@ -5068,21 +5426,43 @@ var SubAgentsBluMa = class {
   }
 };
 
+// src/app/agent/routeManager.ts
+var RouteManager = class {
+  routeHandlers;
+  subAgents;
+  core;
+  constructor(subAgents, core) {
+    this.routeHandlers = /* @__PURE__ */ new Map();
+    this.subAgents = subAgents;
+    this.core = core;
+  }
+  registerRoute(path18, handler) {
+    this.routeHandlers.set(path18, handler);
+  }
+  async handleRoute(payload) {
+    const inputText = String(payload.content || "").trim();
+    for (const [path18, handler] of this.routeHandlers) {
+      if (inputText === path18 || inputText.startsWith(`${path18} `)) {
+        return handler({ content: inputText });
+      }
+    }
+    await this.core.processTurn({ content: inputText });
+  }
+};
+
 // src/app/agent/agent.ts
-var globalEnvPath = path15.join(os8.homedir(), ".bluma-cli", ".env");
+var globalEnvPath = path16.join(os9.homedir(), ".bluma-cli", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
   eventBus;
   mcpClient;
   feedbackSystem;
-  // Mantido caso UI dependa de eventos
   llm;
-  deploymentName;
+  routeManager;
+  model;
   core;
-  // Delegado
   subAgents;
-  // Orquestrador de subagentes
   toolInvoker;
   constructor(sessionId2, eventBus2) {
     this.sessionId = sessionId2;
@@ -5091,75 +5471,53 @@ var Agent = class {
     this.toolInvoker = nativeToolInvoker;
     this.mcpClient = new MCPClient(nativeToolInvoker, eventBus2);
     this.feedbackSystem = new AdvancedFeedbackSystem();
-    const endpoint = process.env.AZURE_OPENAI_ENDPOINT;
-    const apiKey = process.env.OPENROUTER_API_KEY;
-    const apiVersion = process.env.AZURE_OPENAI_API_VERSION;
-    this.deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT || "";
-    const missing = [];
-    if (!apiKey) missing.push("OPENROUTER_API_KEY");
-    if (missing.length > 0) {
+    const apiKey = process.env.NOMAD_API_KEY;
+    const baseUrl = process.env.NOMAD_BASE_URL;
+    this.model = process.env.MODEL_NOMAD || "";
+    if (!apiKey) {
       const platform = process.platform;
-      const varList = missing.join(", ");
       let guidance = "";
       if (platform === "win32") {
         guidance = [
           "Windows (PowerShell):",
-          `  $env:${missing[0]}="<value>" # sess\xE3o atual`,
-          ...missing.slice(1).map((v) => `  $env:${v}="<value>"`),
-          "  # Persistir para o utilizador:",
-          ...missing.map((v) => `  [System.Environment]::SetEnvironmentVariable("${v}", "<value>", "User")`),
-          "",
-          "Windows (cmd.exe):",
-          ...missing.map((v) => `  setx ${v} "<value>"`)
-        ].join("");
+          '  $env:NOMAD_API_KEY="<your-key>"',
+          "  # Para persistir:",
+          '  [System.Environment]::SetEnvironmentVariable("NOMAD_API_KEY", "<your-key>", "User")'
+        ].join("\n");
       } else if (platform === "darwin" || platform === "linux") {
         guidance = [
           "macOS/Linux (bash/zsh):",
-          ...missing.map((v) => `  echo 'export ${v}="<value>"' >> ~/.bashrc  # ou ~/.zshrc`),
-          "  source ~/.bashrc  # ou: source ~/.zshrc"
-        ].join("");
+          `  echo 'export NOMAD_API_KEY="<your-key>"' >> ~/.bashrc`,
+          "  source ~/.bashrc"
+        ].join("\n");
       } else {
-        guidance = [
-          "Generic POSIX:",
-          ...missing.map((v) => `  export ${v}="<value>"`)
-        ].join("");
+        guidance = '  export NOMAD_API_KEY="<your-key>"';
       }
-      const message = [
-        `Missing required environment variables: ${varList}.`,
-        `Configure them globally using the commands below (based on your OS), or set them in the config file: ${globalEnvPath}.`,
+      const message2 = [
+        "Missing required environment variable: NOMAD_API_KEY.",
+        `Configure it globally using the commands below, or set it in: ${globalEnvPath}`,
         "",
         guidance
-      ].join("");
+      ].join("\n");
       this.eventBus.emit("backend_message", {
         type: "error",
         code: "missing_env",
-        missing,
+        missing: ["NOMAD_API_KEY", "MODEL_NOMAD"],
         path: globalEnvPath,
-        message
+        message: message2
       });
-      throw new Error(message);
-    }
-    const ollama = new OpenAI({
-      //baseURL: "http://127.0.0.1:11434/v1",
-      //baseURL: "http://localhost:8000/v1",
-      //baseURL: "https://api.groq.com/openai/v1",
-      //baseURL: "https://api.cerebras.ai/v1",
-      baseURL: "https://openrouter.ai/api/v1",
-      apiKey: apiKey || "",
-      // Buscar do environment do sistema
-      defaultHeaders: {
-        "HTTP-Referer": "<YOUR_SITE_URL>",
-        // Optional. Site URL for rankings on openrouter.ai.
-        "X-Title": "<YOUR_SITE_NAME>"
-        // Optional. Site title for rankings on openrouter.ai.
-      }
+      throw new Error(message2);
+    }
+    this.llm = new LLMService({
+      apiKey,
+      baseUrl,
+      model: this.model
     });
-    this.llm = new OpenAIAdapter(ollama);
     this.core = new BluMaAgent(
       this.sessionId,
       this.eventBus,
       this.llm,
-      this.deploymentName,
+      this.model,
       this.mcpClient,
       this.feedbackSystem
     );
@@ -5168,9 +5526,10 @@ var Agent = class {
       mcpClient: this.mcpClient,
       toolInvoker: this.toolInvoker,
       llm: this.llm,
-      deploymentName: this.deploymentName,
+      deploymentName: this.model,
       projectRoot: process.cwd()
     });
+    this.routeManager = new RouteManager(this.subAgents, this.core);
   }
   async initialize() {
     await this.core.initialize();
@@ -5184,10 +5543,9 @@ var Agent = class {
   async processTurn(userInput) {
     const inputText = String(userInput.content || "").trim();
     if (inputText === "/init" || inputText.startsWith("/init ")) {
-      await this.dispatchToSubAgent({ command: "/init", content: inputText });
-      return;
+      this.routeManager.registerRoute("/init", this.dispatchToSubAgent);
     }
-    await this.core.processTurn({ content: inputText });
+    await this.routeManager.handleRoute({ content: inputText });
   }
   async handleToolResponse(decisionData) {
     await this.core.handleToolResponse(decisionData);
@@ -5286,12 +5644,12 @@ var renderShellCommand2 = ({ args }) => {
 };
 var renderLsTool2 = ({ args }) => {
   const parsed = parseArgs(args);
-  const path17 = parsed.directory_path || ".";
+  const path18 = parsed.directory_path || ".";
   return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
     /* @__PURE__ */ jsx8(Text8, { color: "white", bold: true, children: "ls" }),
     /* @__PURE__ */ jsxs8(Text8, { children: [
       " ",
-      path17
+      path18
     ] })
   ] });
 };
@@ -5422,7 +5780,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path17 = parsed.path || ".";
+  const path18 = parsed.path || ".";
   return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
     /* @__PURE__ */ jsx8(Text8, { color: "white", bold: true, children: "grep" }),
     /* @__PURE__ */ jsxs8(Text8, { color: "white", children: [
@@ -5432,7 +5790,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs8(Text8, { children: [
       " ",
-      path17
+      path18
     ] })
   ] });
 };
@@ -5500,6 +5858,17 @@ var renderSearchWeb = ({ args }) => {
     ] })
   ] });
 };
+var renderLoadSkill = ({ args }) => {
+  const parsed = parseArgs(args);
+  const skillName = parsed.skill_name || "[no skill]";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "white", bold: true, children: "load skill" }),
+    /* @__PURE__ */ jsxs8(Text8, { color: "white", children: [
+      " ",
+      skillName
+    ] })
+  ] });
+};
 var renderGeneric2 = ({ toolName, args }) => {
   const parsed = parseArgs(args);
   const keys = Object.keys(parsed).slice(0, 2);
@@ -5524,13 +5893,14 @@ var ToolRenderDisplay = {
   view_file_outline: renderViewFileOutline,
   command_status: renderCommandStatus,
   task_boundary: renderTaskBoundary,
-  search_web: renderSearchWeb
+  search_web: renderSearchWeb,
+  load_skill: renderLoadSkill
 };
 
 // src/app/ui/components/ToolCallDisplay.tsx
 import { jsx as jsx9 } from "react/jsx-runtime";
 var ToolCallDisplayComponent = ({ toolName, args, preview }) => {
-  if (toolName.includes("message_notify_user") || toolName.includes("agent_end_turn")) {
+  if (toolName.includes("message")) {
     return null;
   }
   const Renderer = ToolRenderDisplay[toolName] || ((props2) => renderGeneric2({ ...props2, toolName }));
@@ -5731,11 +6101,11 @@ var truncateLines = (text, max) => {
   };
 };
 var ToolResultDisplayComponent = ({ toolName, result }) => {
-  if (toolName.includes("agent_end_turn") || toolName.includes("task_boundary")) {
+  if (toolName.includes("task_boundary")) {
     return null;
   }
   const parsed = parseResult(result);
-  if (toolName.includes("message_notify_user")) {
+  if (toolName.includes("message")) {
     const body = parsed?.content?.body || parsed?.body || parsed?.message;
     if (!body) return null;
     return /* @__PURE__ */ jsx11(Box11, { paddingX: 1, marginBottom: 1, flexDirection: "column", children: /* @__PURE__ */ jsx11(MarkdownRenderer, { markdown: body }) });
@@ -5818,6 +6188,23 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
       ] })
     ] });
   }
+  if (toolName.includes("load_skill") && parsed) {
+    if (!parsed.success) {
+      return /* @__PURE__ */ jsx11(Box11, { paddingLeft: 3, children: /* @__PURE__ */ jsxs10(Text10, { dimColor: true, color: "red", children: [
+        "\u2717 Skill not found: ",
+        parsed.message
+      ] }) });
+    }
+    return /* @__PURE__ */ jsxs10(Box11, { paddingLeft: 3, marginBottom: 2, children: [
+      /* @__PURE__ */ jsx11(Text10, { dimColor: true, color: "green", children: "Skill loaded: " }),
+      /* @__PURE__ */ jsx11(Text10, { color: "green", bold: true, children: parsed.skill_name }),
+      /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        " \u2014 ",
+        parsed.description?.slice(0, 50),
+        parsed.description?.length > 100 ? "..." : ""
+      ] })
+    ] });
+  }
   if (toolName.includes("todo")) {
     return null;
   }
@@ -6019,16 +6406,16 @@ var SlashCommands_default = SlashCommands;
 // src/app/agent/utils/update_check.ts
 import updateNotifier from "update-notifier";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import path16 from "path";
-import fs12 from "fs";
+import path17 from "path";
+import fs13 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
 function findBlumaPackageJson(startDir) {
   let dir = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = path16.join(dir, "package.json");
-    if (fs12.existsSync(candidate)) {
+    const candidate = path17.join(dir, "package.json");
+    if (fs13.existsSync(candidate)) {
       try {
-        const raw = fs12.readFileSync(candidate, "utf8");
+        const raw = fs13.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: parsed.version };
@@ -6036,7 +6423,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path16.dirname(dir);
+    const parent = path17.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6049,12 +6436,12 @@ async function checkForUpdates() {
     }
     const binPath = process.argv?.[1];
     let pkg = null;
-    if (binPath && fs12.existsSync(binPath)) {
-      pkg = findBlumaPackageJson(path16.dirname(binPath));
+    if (binPath && fs13.existsSync(binPath)) {
+      pkg = findBlumaPackageJson(path17.dirname(binPath));
     }
     if (!pkg) {
       const __filename = fileURLToPath3(import.meta.url);
-      const __dirname = path16.dirname(__filename);
+      const __dirname = path17.dirname(__filename);
       pkg = findBlumaPackageJson(__dirname);
     }
     if (!pkg) {
@@ -6100,11 +6487,11 @@ function parseUpdateMessage(msg) {
     hint: hintLine || void 0
   };
 }
-var UpdateNotice = ({ message }) => {
-  const { name, current, latest, hint } = parseUpdateMessage(message);
+var UpdateNotice = ({ message: message2 }) => {
+  const { name, current, latest, hint } = parseUpdateMessage(message2);
   return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ jsx13(Text12, { color: "yellow", bold: true, children: "Update Available" }),
-    name && current && latest ? /* @__PURE__ */ jsx13(Text12, { color: "gray", children: `${name}: ${current} \u2192 ${latest}` }) : /* @__PURE__ */ jsx13(Text12, { color: "gray", children: message }),
+    name && current && latest ? /* @__PURE__ */ jsx13(Text12, { color: "gray", children: `${name}: ${current} \u2192 ${latest}` }) : /* @__PURE__ */ jsx13(Text12, { color: "gray", children: message2 }),
     hint ? /* @__PURE__ */ jsx13(Text12, { color: "gray", children: hint }) : null
   ] });
 };
@@ -6113,13 +6500,13 @@ var UpdateNotice_default = UpdateNotice;
 // src/app/ui/components/ErrorMessage.tsx
 import { Box as Box14, Text as Text13 } from "ink";
 import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
-var ErrorMessage = ({ message, details, hint }) => {
+var ErrorMessage = ({ message: message2, details, hint }) => {
   return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
     /* @__PURE__ */ jsxs13(Box14, { children: [
       /* @__PURE__ */ jsx14(Text13, { color: "red", children: "\u2717" }),
       /* @__PURE__ */ jsx14(Text13, { color: "red", bold: true, children: " Error" })
     ] }),
-    /* @__PURE__ */ jsx14(Box14, { paddingLeft: 2, children: /* @__PURE__ */ jsx14(Text13, { color: "red", children: message }) }),
+    /* @__PURE__ */ jsx14(Box14, { paddingLeft: 2, children: /* @__PURE__ */ jsx14(Text13, { color: "red", children: message2 }) }),
     details && /* @__PURE__ */ jsx14(Box14, { paddingLeft: 2, children: /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: details }) }),
     hint && /* @__PURE__ */ jsx14(Box14, { paddingLeft: 2, children: /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
       "hint: ",
@@ -6155,7 +6542,7 @@ var ReasoningDisplay = memo9(ReasoningDisplayComponent);
 import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
 var SAFE_AUTO_APPROVE_TOOLS = [
   // Comunicação/UI
-  "message_notify_user",
+  "message",
   "agent_end_turn",
   "todo",
   "task_boundary",