@nomad-e/bluma-cli 0.0.108 → 0.0.110

package/dist/main.js

@@ -1,491 +1,660 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-
-// 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";
-import { EventEmitter as EventEmitter2 } from "events";
-import { v4 as uuidv43 } from "uuid";
-
-// src/app/ui/App.tsx
-import { useState as useState6, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback2, memo as memo10 } from "react";
-import { Box as Box16, Text as Text15, Static } from "ink";
-
-// src/app/ui/layout.tsx
-import { Box, Text } from "ink";
-import { memo } from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-var HeaderComponent = ({
-  sessionId: sessionId2,
-  workdir
-}) => {
-  const dirName = workdir.split("/").pop() || workdir;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: "bluma \u2014 coding agent" }) }),
-    /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "cwd " }),
-      /* @__PURE__ */ jsx(Text, { color: "cyan", children: dirName }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " | " }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "session " }),
-      /* @__PURE__ */ jsx(Text, { color: "gray", children: sessionId2.slice(0, 8) })
-    ] })
-  ] });
-};
-var Header = memo(HeaderComponent);
-var SessionInfoComponent = ({
-  sessionId: sessionId2,
-  workdir,
-  toolsCount,
-  mcpStatus
-}) => /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
-  /* @__PURE__ */ jsx(Text, { dimColor: true, children: "mcp " }),
-  /* @__PURE__ */ jsx(Text, { color: mcpStatus === "connected" ? "green" : "yellow", children: mcpStatus === "connected" ? "+" : "-" }),
-  toolsCount !== null && /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-    " ",
-    toolsCount,
-    " tools"
-  ] }) })
-] });
-var SessionInfo = memo(SessionInfoComponent);
-var TaskStatusBarComponent = ({
-  taskName,
-  mode,
-  status
-}) => {
-  const modeColors = {
-    PLANNING: "blue",
-    EXECUTION: "green",
-    VERIFICATION: "yellow"
-  };
-  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
-    /* @__PURE__ */ jsxs(Text, { color: modeColors[mode], bold: true, children: [
-      "[",
-      mode.charAt(0),
-      "]"
-    ] }),
-    /* @__PURE__ */ jsxs(Text, { children: [
-      " ",
-      taskName
-    ] }),
-    status && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-      " - ",
-      status
-    ] })
-  ] });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var TaskStatusBar = memo(TaskStatusBarComponent);
-
-// src/app/ui/components/InputPrompt.tsx
-import { Box as Box2, Text as Text2, useStdout, useInput as useInput2 } from "ink";
 
-// src/app/ui/utils/useSimpleInputBuffer.ts
-import { useReducer, useRef, useCallback, useEffect } from "react";
-import { useInput } from "ink";
-function getLineStart(text, cursorPos) {
-  let pos = cursorPos - 1;
-  while (pos >= 0 && text[pos] !== "\n") {
-    pos--;
+// src/app/agent/tools/natives/async_command.ts
+var async_command_exports = {};
+__export(async_command_exports, {
+  commandStatus: () => commandStatus,
+  killCommand: () => killCommand,
+  runCommandAsync: () => runCommandAsync,
+  sendCommandInput: () => sendCommandInput
+});
+import os2 from "os";
+import { spawn } from "child_process";
+import { v4 as uuidv42 } from "uuid";
+function cleanupOldCommands() {
+  if (runningCommands.size <= MAX_STORED_COMMANDS) return;
+  const commands = Array.from(runningCommands.entries()).filter(([_, cmd]) => cmd.status !== "running").sort((a, b) => (a[1].endTime || 0) - (b[1].endTime || 0));
+  const toRemove = commands.slice(0, commands.length - MAX_STORED_COMMANDS + 10);
+  for (const [id] of toRemove) {
+    runningCommands.delete(id);
   }
-  return pos + 1;
 }
-function getLineEnd(text, cursorPos) {
-  let pos = cursorPos;
-  while (pos < text.length && text[pos] !== "\n") {
-    pos++;
+function isDangerousCommand(command) {
+  const trimmed = command.trim();
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
+    }
   }
-  return pos;
-}
-function moveToAdjacentLine(text, cursorPos, direction) {
-  const currentLineStart = getLineStart(text, cursorPos);
-  const currentLineEnd = getLineEnd(text, cursorPos);
-  const column = cursorPos - currentLineStart;
-  if (direction === "up") {
-    if (currentLineStart === 0) return cursorPos;
-    const prevLineEnd = currentLineStart - 1;
-    const prevLineStart = getLineStart(text, prevLineEnd);
-    const prevLineLength = prevLineEnd - prevLineStart;
-    return prevLineStart + Math.min(column, prevLineLength);
-  } else {
-    if (currentLineEnd === text.length) return cursorPos;
-    const nextLineStart = currentLineEnd + 1;
-    const nextLineEnd = getLineEnd(text, nextLineStart);
-    const nextLineLength = nextLineEnd - nextLineStart;
-    return nextLineStart + Math.min(column, nextLineLength);
+  for (const pattern of INTERACTIVE_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return "Interactive commands are not supported in async mode";
+    }
   }
+  return null;
 }
-function inputReducer(state, action, viewWidth) {
-  const adjustView = (newCursorPos, currentViewStart) => {
-    if (newCursorPos < currentViewStart) {
-      return newCursorPos;
-    }
-    if (newCursorPos >= currentViewStart + viewWidth) {
-      return newCursorPos - viewWidth + 1;
+async function runCommandAsync(args) {
+  try {
+    const {
+      command,
+      cwd = process.cwd(),
+      timeout = 0
+    } = args;
+    if (!command || typeof command !== "string") {
+      return {
+        success: false,
+        error: "command is required and must be a string"
+      };
     }
-    return currentViewStart;
-  };
-  switch (action.type) {
-    case "INPUT": {
-      const cleanInput = action.payload.replace(/(\r\n|\r)/gm, "\n");
-      const newText = state.text.slice(0, state.cursorPosition) + cleanInput + state.text.slice(state.cursorPosition);
-      const newCursorPosition = state.cursorPosition + cleanInput.length;
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      if (newText === state.text && newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const dangerReason = isDangerousCommand(command);
+    if (dangerReason) {
+      return {
+        success: false,
+        error: dangerReason
+      };
     }
-    case "NEWLINE": {
-      const newText = state.text.slice(0, state.cursorPosition) + "\n" + state.text.slice(state.cursorPosition);
-      const newCursorPosition = state.cursorPosition + 1;
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const commandId = uuidv42().substring(0, 8);
+    const platform = os2.platform();
+    let shellCmd;
+    let shellArgs;
+    if (platform === "win32") {
+      shellCmd = process.env.COMSPEC || "cmd.exe";
+      shellArgs = ["/c", command];
+    } else {
+      shellCmd = process.env.SHELL || "/bin/bash";
+      shellArgs = ["-c", command];
     }
-    case "MOVE_CURSOR": {
-      let newCursorPosition = state.cursorPosition;
-      if (action.direction === "left" && state.cursorPosition > 0) {
-        newCursorPosition--;
-      } else if (action.direction === "right" && state.cursorPosition < state.text.length) {
-        newCursorPosition++;
-      } else if (action.direction === "up") {
-        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "up");
-      } else if (action.direction === "down") {
-        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "down");
+    const entry = {
+      id: commandId,
+      command,
+      status: "running",
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      startTime: Date.now(),
+      process: null
+    };
+    const child = spawn(shellCmd, shellArgs, {
+      cwd,
+      env: process.env,
+      windowsHide: true
+    });
+    entry.process = child;
+    let stdoutTruncated = false;
+    child.stdout?.on("data", (data) => {
+      if (!stdoutTruncated) {
+        entry.stdout += data.toString();
+        if (entry.stdout.length > MAX_OUTPUT_SIZE) {
+          entry.stdout = entry.stdout.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
+          stdoutTruncated = true;
+        }
       }
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
+    });
+    let stderrTruncated = false;
+    child.stderr?.on("data", (data) => {
+      if (!stderrTruncated) {
+        entry.stderr += data.toString();
+        if (entry.stderr.length > MAX_OUTPUT_SIZE) {
+          entry.stderr = entry.stderr.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
+          stderrTruncated = true;
+        }
       }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    });
+    child.on("close", (code) => {
+      entry.exitCode = code;
+      entry.status = code === 0 ? "completed" : "error";
+      entry.endTime = Date.now();
+      entry.process = null;
+    });
+    child.on("error", (error) => {
+      entry.stderr += `
+Process error: ${error.message}`;
+      entry.status = "error";
+      entry.endTime = Date.now();
+      entry.process = null;
+    });
+    if (timeout > 0) {
+      setTimeout(() => {
+        if (entry.status === "running") {
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (entry.status === "running") {
+              child.kill("SIGKILL");
+            }
+          }, 2e3);
+          entry.status = "timeout";
+          entry.stderr += `
+Command timed out after ${timeout} seconds`;
+        }
+      }, timeout * 1e3);
     }
-    case "MOVE_LINE_START": {
-      const newCursorPosition = getLineStart(state.text, state.cursorPosition);
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    runningCommands.set(commandId, entry);
+    cleanupOldCommands();
+    return {
+      success: true,
+      command_id: commandId,
+      command,
+      message: `Command started in background. Use command_status with id "${commandId}" to check progress.`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+async function commandStatus(args) {
+  try {
+    const {
+      command_id,
+      wait_seconds = 0,
+      output_limit = 1e4
+    } = args;
+    if (!command_id) {
+      return {
+        success: false,
+        command_id: "",
+        status: "error",
+        error: "command_id is required"
+      };
     }
-    case "MOVE_LINE_END": {
-      const newCursorPosition = getLineEnd(state.text, state.cursorPosition);
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        command_id,
+        status: "not_found",
+        error: `Command with id "${command_id}" not found. It may have expired or never existed.`
+      };
     }
-    case "BACKSPACE": {
-      if (state.cursorPosition > 0) {
-        const newText = state.text.slice(0, state.cursorPosition - 1) + state.text.slice(state.cursorPosition);
-        const newCursorPosition = state.cursorPosition - 1;
-        const newViewStart = adjustView(newCursorPosition, state.viewStart);
-        return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
-      }
-      return state;
+    const maxWait = Math.min(wait_seconds, 15);
+    if (maxWait > 0 && entry.status === "running") {
+      await new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (entry.status !== "running") {
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 100);
+        setTimeout(() => {
+          clearInterval(checkInterval);
+          resolve();
+        }, maxWait * 1e3);
+      });
     }
-    case "DELETE": {
-      if (state.cursorPosition < state.text.length) {
-        const newText = state.text.slice(0, state.cursorPosition) + state.text.slice(state.cursorPosition + 1);
-        const newViewStart = adjustView(state.cursorPosition, state.viewStart);
-        return { text: newText, cursorPosition: state.cursorPosition, viewStart: newViewStart };
-      }
-      return state;
+    let stdout = entry.stdout;
+    let stderr = entry.stderr;
+    let truncated = false;
+    if (stdout.length > output_limit) {
+      stdout = "..." + stdout.substring(stdout.length - output_limit);
+      truncated = true;
     }
-    case "SUBMIT": {
-      return { text: "", cursorPosition: 0, viewStart: 0 };
+    if (stderr.length > output_limit) {
+      stderr = "..." + stderr.substring(stderr.length - output_limit);
+      truncated = true;
     }
-    case "SET": {
-      const t = action.payload.text.replace(/(\r\n|\r)/gm, "\n");
-      let newCursorPosition;
-      if (typeof action.payload.cursorPosition === "number") {
-        newCursorPosition = Math.min(action.payload.cursorPosition, t.length);
-      } else if (action.payload.moveCursorToEnd ?? true) {
-        newCursorPosition = t.length;
-      } else {
-        newCursorPosition = Math.min(state.cursorPosition, t.length);
-      }
-      const newText = t;
-      const newViewStart = adjustView(newCursorPosition, 0);
-      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const duration = entry.endTime ? (entry.endTime - entry.startTime) / 1e3 : (Date.now() - entry.startTime) / 1e3;
+    return {
+      success: true,
+      command_id,
+      status: entry.status,
+      stdout: stdout || void 0,
+      stderr: stderr || void 0,
+      exit_code: entry.exitCode,
+      duration_seconds: Math.round(duration * 10) / 10,
+      truncated
+    };
+  } catch (error) {
+    return {
+      success: false,
+      command_id: args.command_id || "",
+      status: "error",
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+async function sendCommandInput(args) {
+  try {
+    const { command_id, input } = args;
+    if (!command_id || input === void 0) {
+      return {
+        success: false,
+        error: "command_id and input are required"
+      };
     }
-    case "SET_CURSOR": {
-      const newCursorPosition = Math.max(0, Math.min(action.payload, state.text.length));
-      if (newCursorPosition === state.cursorPosition) {
-        return state;
-      }
-      const newViewStart = adjustView(newCursorPosition, state.viewStart);
-      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        error: `Command with id "${command_id}" not found`
+      };
     }
-    default:
-      return state;
+    if (entry.status !== "running" || !entry.process) {
+      return {
+        success: false,
+        error: `Command is not running (status: ${entry.status})`
+      };
+    }
+    entry.process.stdin?.write(input);
+    return {
+      success: true,
+      message: `Sent ${input.length} characters to command ${command_id}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to send input: ${error.message}`
+    };
   }
 }
-var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
-  const [state, dispatch] = useReducer(
-    (s, a) => inputReducer(s, a, viewWidth),
-    { text: "", cursorPosition: 0, viewStart: 0 }
-  );
-  const inputBuffer = useRef("");
-  const flushScheduled = useRef(false);
-  const flushInputBuffer = useCallback(() => {
-    if (inputBuffer.current.length > 0) {
-      const buffered = inputBuffer.current;
-      inputBuffer.current = "";
-      dispatch({ type: "INPUT", payload: buffered });
+async function killCommand(args) {
+  try {
+    const { command_id } = args;
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        error: `Command with id "${command_id}" not found`
+      };
     }
-    flushScheduled.current = false;
-  }, []);
-  useEffect(() => {
-    return () => {
-      if (flushScheduled.current) {
-        flushInputBuffer();
-      }
+    if (entry.status !== "running" || !entry.process) {
+      return {
+        success: false,
+        error: `Command is not running (status: ${entry.status})`
+      };
+    }
+    entry.process.kill("SIGTERM");
+    entry.status = "killed";
+    entry.endTime = Date.now();
+    return {
+      success: true,
+      message: `Command ${command_id} killed`
     };
-  }, [flushInputBuffer]);
-  useInput(
-    (input, key) => {
-      const hasBackspaceFlag = key.backspace;
-      const hasDeleteFlag = key.delete;
-      const hasBackspaceChar = input === "\x7F" || input === "\b" || input === "\b" || input.charCodeAt(0) === 127 || input.charCodeAt(0) === 8;
-      if (hasBackspaceFlag || hasBackspaceChar) {
-        if (inputBuffer.current.length > 0) {
-          flushInputBuffer();
-        }
-        dispatch({ type: "BACKSPACE" });
-        return;
-      }
-      if (hasDeleteFlag && (key.ctrl || key.meta)) {
-        if (inputBuffer.current.length > 0) {
-          flushInputBuffer();
-        }
-        dispatch({ type: "DELETE" });
-        return;
-      }
-      if (hasDeleteFlag && !key.ctrl && !key.meta) {
-        if (inputBuffer.current.length > 0) {
-          flushInputBuffer();
-        }
-        dispatch({ type: "BACKSPACE" });
-        return;
-      }
-      if (inputBuffer.current.length > 0 && (key.ctrl || key.meta || key.escape || key.return || key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.tab || key.shift)) {
-        flushInputBuffer();
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to kill command: ${error.message}`
+    };
+  }
+}
+var runningCommands, MAX_OUTPUT_SIZE, MAX_STORED_COMMANDS, OUTPUT_TRUNCATION_MSG, DANGEROUS_PATTERNS, INTERACTIVE_PATTERNS;
+var init_async_command = __esm({
+  "src/app/agent/tools/natives/async_command.ts"() {
+    "use strict";
+    runningCommands = /* @__PURE__ */ new Map();
+    MAX_OUTPUT_SIZE = 3e4;
+    MAX_STORED_COMMANDS = 50;
+    OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED - 30KB/200 lines max]";
+    DANGEROUS_PATTERNS = [
+      // Elevação de privilégios
+      /^sudo\s+/i,
+      /^doas\s+/i,
+      /^su\s+/i,
+      /^pkexec\s+/i,
+      /\|\s*sudo\s+/i,
+      /;\s*sudo\s+/i,
+      /&&\s*sudo\s+/i,
+      // Comandos destrutivos
+      /\brm\s+(-[rf]+\s+)*[\/~]/i,
+      /\brm\s+-[rf]*\s+\*/i,
+      /\bchmod\s+(777|666)\s+\//i,
+      /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i,
+      /\bmkfs\./i,
+      // Fork bombs
+      /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
+      // Remote code exec
+      /\bcurl\s+.*\|\s*(ba)?sh/i,
+      /\bwget\s+.*\|\s*(ba)?sh/i
+    ];
+    INTERACTIVE_PATTERNS = [
+      /^(vim|vi|nano|emacs|pico)\s*/i,
+      /^(less|more|most)\s*/i,
+      /^(top|htop|btop|atop|nmon)\s*/i,
+      /^(ssh|telnet|ftp|sftp)\s+/i,
+      /^(mysql|psql|redis-cli|mongo|mongosh)\s*$/i,
+      /^(python|python3|node|ruby|irb|lua)\s*$/i,
+      /^(gdb|lldb)\s*/i
+    ];
+  }
+});
+
+// src/main.ts
+import React10 from "react";
+import { render } from "ink";
+import { EventEmitter as EventEmitter2 } from "events";
+import { v4 as uuidv43 } from "uuid";
+
+// src/app/ui/App.tsx
+import { useState as useState6, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback2, memo as memo10 } from "react";
+import { Box as Box16, Text as Text15, Static } from "ink";
+
+// src/app/ui/layout.tsx
+import { Box, Text } from "ink";
+import { memo } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var HeaderComponent = ({
+  sessionId: sessionId2,
+  workdir
+}) => {
+  const dirName = workdir.split("/").pop() || workdir;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: "bluma \u2014 coding agent" }) }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "cwd " }),
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: dirName }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " | " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "session " }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: sessionId2.slice(0, 8) })
+    ] })
+  ] });
+};
+var Header = memo(HeaderComponent);
+var SessionInfoComponent = ({
+  sessionId: sessionId2,
+  workdir,
+  toolsCount,
+  mcpStatus
+}) => /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+  /* @__PURE__ */ jsx(Text, { dimColor: true, children: "mcp " }),
+  /* @__PURE__ */ jsx(Text, { color: mcpStatus === "connected" ? "green" : "yellow", children: mcpStatus === "connected" ? "+" : "-" }),
+  toolsCount !== null && /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    " ",
+    toolsCount,
+    " tools"
+  ] }) })
+] });
+var SessionInfo = memo(SessionInfoComponent);
+var TaskStatusBarComponent = ({
+  taskName,
+  mode,
+  status
+}) => {
+  const modeColors = {
+    PLANNING: "blue",
+    EXECUTION: "green",
+    VERIFICATION: "yellow"
+  };
+  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: modeColors[mode], bold: true, children: [
+      "[",
+      mode.charAt(0),
+      "]"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      taskName
+    ] }),
+    status && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " - ",
+      status
+    ] })
+  ] });
+};
+var TaskStatusBar = memo(TaskStatusBarComponent);
+
+// src/app/ui/components/InputPrompt.tsx
+import { Box as Box2, Text as Text2, useStdout, useInput as useInput2 } from "ink";
+
+// src/app/ui/utils/useSimpleInputBuffer.ts
+import { useReducer, useRef, useCallback, useEffect } from "react";
+import { useInput } from "ink";
+function getLineStart(text, cursorPos) {
+  let pos = cursorPos - 1;
+  while (pos >= 0 && text[pos] !== "\n") {
+    pos--;
+  }
+  return pos + 1;
+}
+function getLineEnd(text, cursorPos) {
+  let pos = cursorPos;
+  while (pos < text.length && text[pos] !== "\n") {
+    pos++;
+  }
+  return pos;
+}
+function moveToAdjacentLine(text, cursorPos, direction) {
+  const currentLineStart = getLineStart(text, cursorPos);
+  const currentLineEnd = getLineEnd(text, cursorPos);
+  const column = cursorPos - currentLineStart;
+  if (direction === "up") {
+    if (currentLineStart === 0) return cursorPos;
+    const prevLineEnd = currentLineStart - 1;
+    const prevLineStart = getLineStart(text, prevLineEnd);
+    const prevLineLength = prevLineEnd - prevLineStart;
+    return prevLineStart + Math.min(column, prevLineLength);
+  } else {
+    if (currentLineEnd === text.length) return cursorPos;
+    const nextLineStart = currentLineEnd + 1;
+    const nextLineEnd = getLineEnd(text, nextLineStart);
+    const nextLineLength = nextLineEnd - nextLineStart;
+    return nextLineStart + Math.min(column, nextLineLength);
+  }
+}
+function inputReducer(state, action, viewWidth) {
+  const adjustView = (newCursorPos, currentViewStart) => {
+    if (newCursorPos < currentViewStart) {
+      return newCursorPos;
+    }
+    if (newCursorPos >= currentViewStart + viewWidth) {
+      return newCursorPos - viewWidth + 1;
+    }
+    return currentViewStart;
+  };
+  switch (action.type) {
+    case "INPUT": {
+      const cleanInput = action.payload.replace(/(\r\n|\r)/gm, "\n");
+      const newText = state.text.slice(0, state.cursorPosition) + cleanInput + state.text.slice(state.cursorPosition);
+      const newCursorPosition = state.cursorPosition + cleanInput.length;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      if (newText === state.text && newCursorPosition === state.cursorPosition) {
+        return state;
       }
-      if (key.escape) {
-        onInterrupt();
-        return;
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "NEWLINE": {
+      const newText = state.text.slice(0, state.cursorPosition) + "\n" + state.text.slice(state.cursorPosition);
+      const newCursorPosition = state.cursorPosition + 1;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "MOVE_CURSOR": {
+      let newCursorPosition = state.cursorPosition;
+      if (action.direction === "left" && state.cursorPosition > 0) {
+        newCursorPosition--;
+      } else if (action.direction === "right" && state.cursorPosition < state.text.length) {
+        newCursorPosition++;
+      } else if (action.direction === "up") {
+        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "up");
+      } else if (action.direction === "down") {
+        newCursorPosition = moveToAdjacentLine(state.text, state.cursorPosition, "down");
       }
-      if (isReadOnly) {
-        if (key.return && !key.shift) {
-          if (state.text.trim().length > 0) {
-            onSubmit(state.text);
-            dispatch({ type: "SUBMIT" });
-          }
-          return;
-        }
-        if (key.shift && key.return) {
-          dispatch({ type: "NEWLINE" });
-          return;
-        }
-        if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
-        if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
-        if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
-        if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
-        if (key.ctrl || key.meta || key.tab) return;
-        inputBuffer.current += input;
-        if (!flushScheduled.current) {
-          flushScheduled.current = true;
-          queueMicrotask(flushInputBuffer);
-        }
-        return;
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
       }
-      if (key.return && key.shift) {
-        dispatch({ type: "NEWLINE" });
-        return;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "MOVE_LINE_START": {
+      const newCursorPosition = getLineStart(state.text, state.cursorPosition);
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
       }
-      if (key.return) {
-        if (globalThis.__BLUMA_AT_OPEN__) return;
-        if (globalThis.__BLUMA_SUPPRESS_SUBMIT__) {
-          globalThis.__BLUMA_SUPPRESS_SUBMIT__ = false;
-          return;
-        }
-        if (state.text.trim().length > 0) {
-          onSubmit(state.text);
-          dispatch({ type: "SUBMIT" });
-        }
-        return;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "MOVE_LINE_END": {
+      const newCursorPosition = getLineEnd(state.text, state.cursorPosition);
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
       }
-      if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
-      if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
-      if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
-      if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
-      if (key.ctrl && input === "a") {
-        return dispatch({ type: "MOVE_LINE_START" });
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "BACKSPACE": {
+      if (state.cursorPosition > 0) {
+        const newText = state.text.slice(0, state.cursorPosition - 1) + state.text.slice(state.cursorPosition);
+        const newCursorPosition = state.cursorPosition - 1;
+        const newViewStart = adjustView(newCursorPosition, state.viewStart);
+        return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
       }
-      if (key.ctrl && input === "e") {
-        return dispatch({ type: "MOVE_LINE_END" });
+      return state;
+    }
+    case "DELETE": {
+      if (state.cursorPosition < state.text.length) {
+        const newText = state.text.slice(0, state.cursorPosition) + state.text.slice(state.cursorPosition + 1);
+        const newViewStart = adjustView(state.cursorPosition, state.viewStart);
+        return { text: newText, cursorPosition: state.cursorPosition, viewStart: newViewStart };
       }
-      if (key.ctrl || key.meta || key.tab) return;
-      inputBuffer.current += input;
-      if (!flushScheduled.current) {
-        flushScheduled.current = true;
-        queueMicrotask(flushInputBuffer);
+      return state;
+    }
+    case "SUBMIT": {
+      return { text: "", cursorPosition: 0, viewStart: 0 };
+    }
+    case "SET": {
+      const t = action.payload.text.replace(/(\r\n|\r)/gm, "\n");
+      let newCursorPosition;
+      if (typeof action.payload.cursorPosition === "number") {
+        newCursorPosition = Math.min(action.payload.cursorPosition, t.length);
+      } else if (action.payload.moveCursorToEnd ?? true) {
+        newCursorPosition = t.length;
+      } else {
+        newCursorPosition = Math.min(state.cursorPosition, t.length);
+      }
+      const newText = t;
+      const newViewStart = adjustView(newCursorPosition, 0);
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    case "SET_CURSOR": {
+      const newCursorPosition = Math.max(0, Math.min(action.payload, state.text.length));
+      if (newCursorPosition === state.cursorPosition) {
+        return state;
+      }
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { ...state, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
+    default:
+      return state;
+  }
+}
+var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
+  const [state, dispatch] = useReducer(
+    (s, a) => inputReducer(s, a, viewWidth),
+    { text: "", cursorPosition: 0, viewStart: 0 }
+  );
+  const inputBuffer = useRef("");
+  const flushScheduled = useRef(false);
+  const flushInputBuffer = useCallback(() => {
+    if (inputBuffer.current.length > 0) {
+      const buffered = inputBuffer.current;
+      inputBuffer.current = "";
+      dispatch({ type: "INPUT", payload: buffered });
+    }
+    flushScheduled.current = false;
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (flushScheduled.current) {
+        flushInputBuffer();
+      }
+    };
+  }, [flushInputBuffer]);
+  useInput(
+    (input, key) => {
+      const hasBackspaceFlag = key.backspace;
+      const hasDeleteFlag = key.delete;
+      const hasBackspaceChar = input === "\x7F" || input === "\b" || input === "\b" || input.charCodeAt(0) === 127 || input.charCodeAt(0) === 8;
+      if (hasBackspaceFlag || hasBackspaceChar) {
+        if (inputBuffer.current.length > 0) {
+          flushInputBuffer();
+        }
+        dispatch({ type: "BACKSPACE" });
+        return;
+      }
+      if (hasDeleteFlag && (key.ctrl || key.meta)) {
+        if (inputBuffer.current.length > 0) {
+          flushInputBuffer();
+        }
+        dispatch({ type: "DELETE" });
+        return;
+      }
+      if (hasDeleteFlag && !key.ctrl && !key.meta) {
+        if (inputBuffer.current.length > 0) {
+          flushInputBuffer();
+        }
+        dispatch({ type: "BACKSPACE" });
+        return;
+      }
+      if (inputBuffer.current.length > 0 && (key.ctrl || key.meta || key.escape || key.return || key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.tab || key.shift)) {
+        flushInputBuffer();
+      }
+      if (key.escape) {
+        onInterrupt();
+        return;
+      }
+      if (isReadOnly) {
+        if (key.return && !key.shift) {
+          if (state.text.trim().length > 0) {
+            onSubmit(state.text);
+            dispatch({ type: "SUBMIT" });
+          }
+          return;
+        }
+        if (key.shift && key.return) {
+          dispatch({ type: "NEWLINE" });
+          return;
+        }
+        if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
+        if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
+        if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
+        if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
+        if (key.ctrl || key.meta || key.tab) return;
+        inputBuffer.current += input;
+        if (!flushScheduled.current) {
+          flushScheduled.current = true;
+          queueMicrotask(flushInputBuffer);
+        }
+        return;
+      }
+      if (key.return && key.shift) {
+        dispatch({ type: "NEWLINE" });
+        return;
+      }
+      if (key.return) {
+        if (globalThis.__BLUMA_AT_OPEN__) return;
+        if (globalThis.__BLUMA_SUPPRESS_SUBMIT__) {
+          globalThis.__BLUMA_SUPPRESS_SUBMIT__ = false;
+          return;
+        }
+        if (state.text.trim().length > 0) {
+          onSubmit(state.text);
+          dispatch({ type: "SUBMIT" });
+        }
+        return;
+      }
+      if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
+      if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
+      if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
+      if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
+      if (key.ctrl && input === "a") {
+        return dispatch({ type: "MOVE_LINE_START" });
+      }
+      if (key.ctrl && input === "e") {
+        return dispatch({ type: "MOVE_LINE_END" });
+      }
+      if (key.ctrl || key.meta || key.tab) return;
+      inputBuffer.current += input;
+      if (!flushScheduled.current) {
+        flushScheduled.current = true;
+        queueMicrotask(flushInputBuffer);
       }
     },
     { isActive: true }
@@ -1313,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";
@@ -1665,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
@@ -1830,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 {
@@ -1881,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()
   };
@@ -2064,999 +2232,698 @@ function shouldIgnore(name, ignorePatterns, includeHidden) {
       return true;
     }
   }
-  return false;
-}
-function matchesExtensions(filename, extensions) {
-  if (!extensions || extensions.length === 0) return true;
-  const ext = path6.extname(filename).toLowerCase();
-  return extensions.some((e) => {
-    const normalizedExt = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
-    return ext === normalizedExt;
-  });
-}
-async function searchDirectory(dir, pattern, baseDir, options, results) {
-  if (options.currentDepth > options.maxDepth || results.length >= MAX_RESULTS2) {
-    return;
-  }
-  let entries;
-  try {
-    entries = await fsPromises.readdir(dir, { withFileTypes: true });
-  } catch (error) {
-    return;
-  }
-  for (const entry of entries) {
-    if (results.length >= MAX_RESULTS2) break;
-    const name = entry.name;
-    if (shouldIgnore(name, options.ignorePatterns, options.includeHidden)) {
-      continue;
-    }
-    const fullPath = path6.join(dir, name);
-    const relativePath = path6.relative(baseDir, fullPath);
-    if (entry.isDirectory()) {
-      if (pattern.test(name)) {
-        results.push({
-          path: fullPath,
-          relative_path: relativePath,
-          type: "directory"
-        });
-      }
-      await searchDirectory(fullPath, pattern, baseDir, {
-        ...options,
-        currentDepth: options.currentDepth + 1
-      }, results);
-    } else if (entry.isFile()) {
-      if (pattern.test(name) && matchesExtensions(name, options.extensions)) {
-        try {
-          const stats = await fsPromises.stat(fullPath);
-          results.push({
-            path: fullPath,
-            relative_path: relativePath,
-            type: "file",
-            size: stats.size,
-            modified: stats.mtime.toISOString()
-          });
-        } catch {
-          results.push({
-            path: fullPath,
-            relative_path: relativePath,
-            type: "file"
-          });
-        }
-      }
-    }
-  }
-}
-async function findByName(args) {
-  try {
-    const {
-      pattern,
-      directory = process.cwd(),
-      extensions,
-      max_depth = MAX_DEPTH_DEFAULT,
-      include_hidden = false,
-      exclude_patterns = []
-    } = args;
-    if (!pattern || typeof pattern !== "string") {
-      return {
-        success: false,
-        pattern: pattern || "",
-        directory,
-        results: [],
-        total_found: 0,
-        truncated: false,
-        error: "Pattern is required and must be a string"
-      };
-    }
-    const resolvedDir = path6.resolve(directory);
-    try {
-      const stats = await fsPromises.stat(resolvedDir);
-      if (!stats.isDirectory()) {
-        return {
-          success: false,
-          pattern,
-          directory: resolvedDir,
-          results: [],
-          total_found: 0,
-          truncated: false,
-          error: `Path is not a directory: ${resolvedDir}`
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        pattern,
-        directory: resolvedDir,
-        results: [],
-        total_found: 0,
-        truncated: false,
-        error: `Directory not found: ${resolvedDir}`
-      };
-    }
-    const ignorePatterns = [...DEFAULT_IGNORE_PATTERNS, ...exclude_patterns];
-    const patternRegex = globToRegex(pattern);
-    const results = [];
-    await searchDirectory(resolvedDir, patternRegex, resolvedDir, {
-      extensions,
-      maxDepth: max_depth,
-      currentDepth: 0,
-      includeHidden: include_hidden,
-      ignorePatterns
-    }, results);
-    results.sort((a, b) => {
-      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
-      return a.relative_path.localeCompare(b.relative_path);
-    });
-    return {
-      success: true,
-      pattern,
-      directory: resolvedDir,
-      results,
-      total_found: results.length,
-      truncated: results.length >= MAX_RESULTS2
-    };
-  } catch (error) {
-    return {
-      success: false,
-      pattern: args.pattern || "",
-      directory: args.directory || process.cwd(),
-      results: [],
-      total_found: 0,
-      truncated: false,
-      error: `Unexpected error: ${error.message}`
-    };
-  }
-}
-
-// src/app/agent/tools/natives/grep_search.ts
-import path7 from "path";
-import { promises as fsPromises2 } from "fs";
-var MAX_RESULTS3 = 100;
-var MAX_FILE_SIZE2 = 1024 * 1024;
-var MAX_LINE_LENGTH = 500;
-var DEFAULT_IGNORE2 = [
-  "node_modules",
-  ".git",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".cache",
-  "dist",
-  "build",
-  ".next",
-  "coverage",
-  "*.min.js",
-  "*.min.css",
-  "*.map",
-  "*.lock",
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml"
-];
-var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".py",
-  ".pyw",
-  ".java",
-  ".kt",
-  ".scala",
-  ".go",
-  ".rs",
-  ".rb",
-  ".php",
-  ".cs",
-  ".cpp",
-  ".c",
-  ".h",
-  ".hpp",
-  ".swift",
-  ".vue",
-  ".svelte",
-  ".html",
-  ".htm",
-  ".xml",
-  ".svg",
-  ".css",
-  ".scss",
-  ".sass",
-  ".less",
-  ".json",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".md",
-  ".mdx",
-  ".txt",
-  ".rst",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".fish",
-  ".sql",
-  ".graphql",
-  ".gql",
-  ".env",
-  ".env.local",
-  ".env.example",
-  ".gitignore",
-  ".dockerignore",
-  ".eslintrc",
-  ".prettierrc",
-  "Dockerfile",
-  "Makefile",
-  "Rakefile"
-]);
-function isTextFile(filepath) {
-  const ext = path7.extname(filepath).toLowerCase();
-  const basename = path7.basename(filepath);
-  if (TEXT_EXTENSIONS.has(ext)) return true;
-  if (TEXT_EXTENSIONS.has(basename)) return true;
-  if (basename.startsWith(".") && !ext) return true;
-  return false;
-}
-function shouldIgnore2(name) {
-  for (const pattern of DEFAULT_IGNORE2) {
-    if (pattern.includes("*")) {
-      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
-      if (regex.test(name)) return true;
-    } else if (name === pattern) {
-      return true;
-    }
-  }
-  return false;
-}
-function createSearchPattern(query, isRegex, caseInsensitive) {
-  try {
-    const flags = caseInsensitive ? "gi" : "g";
-    if (isRegex) {
-      return new RegExp(query, flags);
-    } else {
-      const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      return new RegExp(escaped, flags);
-    }
-  } catch (error) {
-    throw new Error(`Invalid regex pattern: ${error.message}`);
-  }
-}
-function matchesIncludePattern(filename, includePatterns) {
-  if (!includePatterns || includePatterns.length === 0) return true;
-  for (const pattern of includePatterns) {
-    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i");
-    if (regex.test(filename)) return true;
-  }
-  return false;
-}
-async function searchFile(filepath, baseDir, pattern, contextLines, matches, maxResults) {
-  let fileMatches = 0;
-  try {
-    const stats = await fsPromises2.stat(filepath);
-    if (stats.size > MAX_FILE_SIZE2) return 0;
-    const content = await fsPromises2.readFile(filepath, "utf-8");
-    const lines = content.split("\n");
-    const relativePath = path7.relative(baseDir, filepath);
-    for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
-      const line = lines[i];
-      pattern.lastIndex = 0;
-      let match;
-      while ((match = pattern.exec(line)) !== null && matches.length < maxResults) {
-        const lineContent = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line;
-        const searchMatch = {
-          file: filepath,
-          relative_path: relativePath,
-          line_number: i + 1,
-          line_content: lineContent.trim(),
-          match_start: match.index,
-          match_end: match.index + match[0].length
-        };
-        if (contextLines > 0) {
-          searchMatch.context_before = lines.slice(Math.max(0, i - contextLines), i).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
-          searchMatch.context_after = lines.slice(i + 1, i + 1 + contextLines).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
-        }
-        matches.push(searchMatch);
-        fileMatches++;
-        if (!pattern.global) break;
-      }
-    }
-  } catch (error) {
-  }
-  return fileMatches;
-}
-async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats) {
-  if (matches.length >= maxResults) return;
-  let entries;
-  try {
-    entries = await fsPromises2.readdir(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (matches.length >= maxResults) break;
-    const name = entry.name;
-    if (shouldIgnore2(name)) continue;
-    const fullPath = path7.join(dir, name);
-    if (entry.isDirectory()) {
-      await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats);
-    } else if (entry.isFile()) {
-      if (!isTextFile(name)) continue;
-      if (!matchesIncludePattern(name, includePatterns)) continue;
-      stats.filesSearched++;
-      const found = await searchFile(fullPath, baseDir, pattern, contextLines, matches, maxResults);
-      if (found > 0) stats.filesWithMatches++;
-    }
-  }
-}
-async function grepSearch(args) {
-  try {
-    const {
-      query,
-      path: searchPath,
-      case_insensitive = true,
-      is_regex = false,
-      include_patterns,
-      max_results = MAX_RESULTS3,
-      context_lines = 0
-    } = args;
-    if (!query || typeof query !== "string") {
-      return {
-        success: false,
-        query: query || "",
-        search_path: searchPath || "",
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
-        truncated: false,
-        error: "Query is required and must be a string"
-      };
-    }
-    if (!searchPath) {
-      return {
-        success: false,
-        query,
-        search_path: "",
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
-        truncated: false,
-        error: "Search path is required"
-      };
-    }
-    const resolvedPath = path7.resolve(searchPath);
-    let stats;
-    try {
-      stats = await fsPromises2.stat(resolvedPath);
-    } catch {
-      return {
-        success: false,
-        query,
-        search_path: resolvedPath,
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
-        truncated: false,
-        error: `Path not found: ${resolvedPath}`
-      };
-    }
-    let pattern;
-    try {
-      pattern = createSearchPattern(query, is_regex, case_insensitive);
-    } catch (error) {
-      return {
-        success: false,
-        query,
-        search_path: resolvedPath,
-        matches: [],
-        files_searched: 0,
-        files_with_matches: 0,
-        total_matches: 0,
-        truncated: false,
-        error: error.message
-      };
-    }
-    const matches = [];
-    const searchStats = { filesSearched: 0, filesWithMatches: 0 };
-    if (stats.isDirectory()) {
-      await searchDirectory2(
-        resolvedPath,
-        resolvedPath,
-        pattern,
-        include_patterns,
-        context_lines,
-        matches,
-        max_results,
-        searchStats
-      );
-    } else if (stats.isFile()) {
-      searchStats.filesSearched = 1;
-      const found = await searchFile(resolvedPath, path7.dirname(resolvedPath), pattern, context_lines, matches, max_results);
-      if (found > 0) searchStats.filesWithMatches = 1;
-    }
-    return {
-      success: true,
-      query,
-      search_path: resolvedPath,
-      matches,
-      files_searched: searchStats.filesSearched,
-      files_with_matches: searchStats.filesWithMatches,
-      total_matches: matches.length,
-      truncated: matches.length >= max_results
-    };
-  } catch (error) {
-    return {
-      success: false,
-      query: args.query || "",
-      search_path: args.path || "",
-      matches: [],
-      files_searched: 0,
-      files_with_matches: 0,
-      total_matches: 0,
-      truncated: false,
-      error: `Unexpected error: ${error.message}`
-    };
-  }
-}
-
-// src/app/agent/tools/natives/view_file_outline.ts
-import path8 from "path";
-import { promises as fsPromises3 } from "fs";
-var LANGUAGE_MAP = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".java": "java",
-  ".go": "go",
-  ".rs": "rust",
-  ".rb": "ruby",
-  ".php": "php",
-  ".cs": "csharp",
-  ".cpp": "cpp",
-  ".c": "c",
-  ".h": "c",
-  ".hpp": "cpp",
-  ".swift": "swift",
-  ".kt": "kotlin",
-  ".scala": "scala"
-};
-var PATTERNS = {
-  typescript: [
-    // Classes
-    /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w,\s]+)?/,
-    // Interfaces
-    /^(?:export\s+)?interface\s+(\w+)/,
-    // Types
-    /^(?:export\s+)?type\s+(\w+)/,
-    // Functions (standalone)
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
-    // Arrow functions assigned to const/let
-    /^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-    // Methods inside classes (indented)
-    /^\s+(?:public|private|protected|static|async|readonly|\s)*(\w+)\s*\([^)]*\)\s*(?::\s*[\w<>\[\]|&\s]+)?\s*\{/,
-    // Const exports
-    /^(?:export\s+)?const\s+(\w+)\s*[:=]/
-  ],
-  javascript: [
-    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/,
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
-    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-    /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/,
-    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/
-  ],
-  python: [
-    /^class\s+(\w+)(?:\([^)]*\))?:/,
-    /^(?:async\s+)?def\s+(\w+)\s*\(/,
-    /^(\w+)\s*=\s*(?:lambda|def)/
-  ],
-  java: [
-    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:abstract)?\s*class\s+(\w+)/,
-    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*interface\s+(\w+)/,
-    /^\s*(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:synchronized)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
-  ],
-  go: [
-    /^type\s+(\w+)\s+struct\s*\{/,
-    /^type\s+(\w+)\s+interface\s*\{/,
-    /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/
-  ],
-  rust: [
-    /^(?:pub\s+)?struct\s+(\w+)/,
-    /^(?:pub\s+)?enum\s+(\w+)/,
-    /^(?:pub\s+)?trait\s+(\w+)/,
-    /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
-    /^impl(?:<[^>]+>)?\s+(?:(\w+)|for\s+(\w+))/
-  ],
-  ruby: [
-    /^class\s+(\w+)/,
-    /^module\s+(\w+)/,
-    /^def\s+(\w+)/
-  ],
-  php: [
-    /^(?:abstract\s+)?class\s+(\w+)/,
-    /^interface\s+(\w+)/,
-    /^(?:public|private|protected)?\s*(?:static)?\s*function\s+(\w+)/
-  ],
-  csharp: [
-    /^(?:public|private|protected|internal)?\s*(?:static)?\s*(?:partial)?\s*class\s+(\w+)/,
-    /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/,
-    /^\s*(?:public|private|protected|internal)?\s*(?:static)?\s*(?:async)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
-  ],
-  swift: [
-    /^(?:public|private|internal|open)?\s*class\s+(\w+)/,
-    /^(?:public|private|internal)?\s*struct\s+(\w+)/,
-    /^(?:public|private|internal)?\s*protocol\s+(\w+)/,
-    /^(?:public|private|internal)?\s*(?:static)?\s*func\s+(\w+)/
-  ],
-  kotlin: [
-    /^(?:open|abstract|sealed)?\s*class\s+(\w+)/,
-    /^interface\s+(\w+)/,
-    /^(?:private|public|internal)?\s*fun\s+(\w+)/
-  ],
-  scala: [
-    /^(?:sealed\s+)?(?:abstract\s+)?class\s+(\w+)/,
-    /^object\s+(\w+)/,
-    /^trait\s+(\w+)/,
-    /^def\s+(\w+)/
-  ],
-  c: [
-    /^(?:static\s+)?(?:inline\s+)?(?:const\s+)?(?:\w+(?:\s*\*)*)\s+(\w+)\s*\([^)]*\)\s*\{/,
-    /^typedef\s+struct\s*\w*\s*\{[^}]*\}\s*(\w+)/,
-    /^struct\s+(\w+)\s*\{/
-  ],
-  cpp: [
-    /^class\s+(\w+)/,
-    /^(?:virtual\s+)?(?:\w+(?:\s*[*&])*)\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
-    /^namespace\s+(\w+)\s*\{/
-  ]
-};
-function detectLanguage(filepath) {
-  const ext = path8.extname(filepath).toLowerCase();
-  return LANGUAGE_MAP[ext] || "unknown";
-}
-function determineItemType(line, language) {
-  const normalizedLine = line.trim().toLowerCase();
-  if (normalizedLine.includes("class ")) return "class";
-  if (normalizedLine.includes("interface ")) return "interface";
-  if (normalizedLine.includes("type ")) return "type";
-  if (normalizedLine.startsWith("import ")) return "import";
-  if (normalizedLine.includes("export ") && !normalizedLine.includes("function") && !normalizedLine.includes("class")) return "export";
-  if (line.startsWith("  ") || line.startsWith("	")) {
-    if (normalizedLine.includes("function") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
-      return "method";
-    }
-    if (/^\s+\w+\s*\(/.test(line)) return "method";
+  return false;
+}
+function matchesExtensions(filename, extensions) {
+  if (!extensions || extensions.length === 0) return true;
+  const ext = path6.extname(filename).toLowerCase();
+  return extensions.some((e) => {
+    const normalizedExt = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
+    return ext === normalizedExt;
+  });
+}
+async function searchDirectory(dir, pattern, baseDir, options, results) {
+  if (options.currentDepth > options.maxDepth || results.length >= MAX_RESULTS2) {
+    return;
   }
-  if (normalizedLine.includes("function ") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
-    return "function";
+  let entries;
+  try {
+    entries = await fsPromises.readdir(dir, { withFileTypes: true });
+  } catch (error) {
+    return;
   }
-  if (normalizedLine.includes("const ") || normalizedLine.includes("let ") || normalizedLine.includes("var ")) {
-    return normalizedLine.includes("=>") ? "function" : "const";
+  for (const entry of entries) {
+    if (results.length >= MAX_RESULTS2) break;
+    const name = entry.name;
+    if (shouldIgnore(name, options.ignorePatterns, options.includeHidden)) {
+      continue;
+    }
+    const fullPath = path6.join(dir, name);
+    const relativePath = path6.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      if (pattern.test(name)) {
+        results.push({
+          path: fullPath,
+          relative_path: relativePath,
+          type: "directory"
+        });
+      }
+      await searchDirectory(fullPath, pattern, baseDir, {
+        ...options,
+        currentDepth: options.currentDepth + 1
+      }, results);
+    } else if (entry.isFile()) {
+      if (pattern.test(name) && matchesExtensions(name, options.extensions)) {
+        try {
+          const stats = await fsPromises.stat(fullPath);
+          results.push({
+            path: fullPath,
+            relative_path: relativePath,
+            type: "file",
+            size: stats.size,
+            modified: stats.mtime.toISOString()
+          });
+        } catch {
+          results.push({
+            path: fullPath,
+            relative_path: relativePath,
+            type: "file"
+          });
+        }
+      }
+    }
   }
-  return "function";
 }
-async function extractOutline(filepath, content, language) {
-  const items = [];
-  const lines = content.split("\n");
-  const patterns = PATTERNS[language] || PATTERNS.javascript;
-  let currentClass = null;
-  let braceCount = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const lineNumber = i + 1;
-    const openBraces = (line.match(/\{/g) || []).length;
-    const closeBraces = (line.match(/\}/g) || []).length;
-    braceCount += openBraces - closeBraces;
-    if (braceCount <= 0 && currentClass) {
-      currentClass = null;
+async function findByName(args) {
+  try {
+    const {
+      pattern,
+      directory = process.cwd(),
+      extensions,
+      max_depth = MAX_DEPTH_DEFAULT,
+      include_hidden = false,
+      exclude_patterns = []
+    } = args;
+    if (!pattern || typeof pattern !== "string") {
+      return {
+        success: false,
+        pattern: pattern || "",
+        directory,
+        results: [],
+        total_found: 0,
+        truncated: false,
+        error: "Pattern is required and must be a string"
+      };
     }
-    for (const pattern of patterns) {
-      const match = line.match(pattern);
-      if (match) {
-        const name = match[1] || match[2];
-        if (!name) continue;
-        const itemType = determineItemType(line, language);
-        if (!itemType) continue;
-        const exported = line.includes("export ");
-        const isInsideClass = currentClass && (line.startsWith("  ") || line.startsWith("	"));
-        const item = {
-          type: itemType,
-          name,
-          line_start: lineNumber,
-          signature: line.trim().substring(0, 120),
-          exported
+    const resolvedDir = path6.resolve(directory);
+    try {
+      const stats = await fsPromises.stat(resolvedDir);
+      if (!stats.isDirectory()) {
+        return {
+          success: false,
+          pattern,
+          directory: resolvedDir,
+          results: [],
+          total_found: 0,
+          truncated: false,
+          error: `Path is not a directory: ${resolvedDir}`
         };
-        if (isInsideClass && itemType === "method" && currentClass) {
-          item.parent = currentClass;
-        }
-        if (itemType === "class") {
-          currentClass = name;
-        }
-        items.push(item);
-        break;
       }
+    } catch (error) {
+      return {
+        success: false,
+        pattern,
+        directory: resolvedDir,
+        results: [],
+        total_found: 0,
+        truncated: false,
+        error: `Directory not found: ${resolvedDir}`
+      };
     }
+    const ignorePatterns = [...DEFAULT_IGNORE_PATTERNS, ...exclude_patterns];
+    const patternRegex = globToRegex(pattern);
+    const results = [];
+    await searchDirectory(resolvedDir, patternRegex, resolvedDir, {
+      extensions,
+      maxDepth: max_depth,
+      currentDepth: 0,
+      includeHidden: include_hidden,
+      ignorePatterns
+    }, results);
+    results.sort((a, b) => {
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.relative_path.localeCompare(b.relative_path);
+    });
+    return {
+      success: true,
+      pattern,
+      directory: resolvedDir,
+      results,
+      total_found: results.length,
+      truncated: results.length >= MAX_RESULTS2
+    };
+  } catch (error) {
+    return {
+      success: false,
+      pattern: args.pattern || "",
+      directory: args.directory || process.cwd(),
+      results: [],
+      total_found: 0,
+      truncated: false,
+      error: `Unexpected error: ${error.message}`
+    };
   }
-  return items;
 }
-function generateSummary(items, totalLines) {
-  const counts = {};
-  for (const item of items) {
-    counts[item.type] = (counts[item.type] || 0) + 1;
+
+// src/app/agent/tools/natives/grep_search.ts
+import path7 from "path";
+import { promises as fsPromises2 } from "fs";
+var MAX_RESULTS3 = 100;
+var MAX_FILE_SIZE2 = 1024 * 1024;
+var MAX_LINE_LENGTH = 500;
+var DEFAULT_IGNORE2 = [
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".cache",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "*.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml"
+];
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".pyw",
+  ".java",
+  ".kt",
+  ".scala",
+  ".go",
+  ".rs",
+  ".rb",
+  ".php",
+  ".cs",
+  ".cpp",
+  ".c",
+  ".h",
+  ".hpp",
+  ".swift",
+  ".vue",
+  ".svelte",
+  ".html",
+  ".htm",
+  ".xml",
+  ".svg",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".rst",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".env",
+  ".env.local",
+  ".env.example",
+  ".gitignore",
+  ".dockerignore",
+  ".eslintrc",
+  ".prettierrc",
+  "Dockerfile",
+  "Makefile",
+  "Rakefile"
+]);
+function isTextFile(filepath) {
+  const ext = path7.extname(filepath).toLowerCase();
+  const basename = path7.basename(filepath);
+  if (TEXT_EXTENSIONS.has(ext)) return true;
+  if (TEXT_EXTENSIONS.has(basename)) return true;
+  if (basename.startsWith(".") && !ext) return true;
+  return false;
+}
+function shouldIgnore2(name) {
+  for (const pattern of DEFAULT_IGNORE2) {
+    if (pattern.includes("*")) {
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+      if (regex.test(name)) return true;
+    } else if (name === pattern) {
+      return true;
+    }
   }
-  const parts = [`${totalLines} lines`];
-  if (counts.class) parts.push(`${counts.class} class${counts.class > 1 ? "es" : ""}`);
-  if (counts.interface) parts.push(`${counts.interface} interface${counts.interface > 1 ? "s" : ""}`);
-  if (counts.function) parts.push(`${counts.function} function${counts.function > 1 ? "s" : ""}`);
-  if (counts.method) parts.push(`${counts.method} method${counts.method > 1 ? "s" : ""}`);
-  if (counts.type) parts.push(`${counts.type} type${counts.type > 1 ? "s" : ""}`);
-  if (counts.const) parts.push(`${counts.const} const${counts.const > 1 ? "s" : ""}`);
-  return parts.join(", ");
+  return false;
 }
-async function viewFileOutline(args) {
+function createSearchPattern(query, isRegex, caseInsensitive) {
   try {
-    const { file_path } = args;
-    if (!file_path || typeof file_path !== "string") {
-      return {
-        success: false,
-        file_path: file_path || "",
-        language: "unknown",
-        total_lines: 0,
-        items: [],
-        summary: "",
-        error: "file_path is required and must be a string"
-      };
-    }
-    const resolvedPath = path8.resolve(file_path);
-    let content;
-    try {
-      content = await fsPromises3.readFile(resolvedPath, "utf-8");
-    } catch (error) {
-      return {
-        success: false,
-        file_path: resolvedPath,
-        language: "unknown",
-        total_lines: 0,
-        items: [],
-        summary: "",
-        error: error.code === "ENOENT" ? `File not found: ${resolvedPath}` : `Error reading file: ${error.message}`
-      };
+    const flags = caseInsensitive ? "gi" : "g";
+    if (isRegex) {
+      return new RegExp(query, flags);
+    } else {
+      const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(escaped, flags);
     }
-    const language = detectLanguage(resolvedPath);
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    const items = await extractOutline(resolvedPath, content, language);
-    return {
-      success: true,
-      file_path: resolvedPath,
-      language,
-      total_lines: totalLines,
-      items,
-      summary: generateSummary(items, totalLines)
-    };
   } catch (error) {
-    return {
-      success: false,
-      file_path: args.file_path || "",
-      language: "unknown",
-      total_lines: 0,
-      items: [],
-      summary: "",
-      error: `Unexpected error: ${error.message}`
-    };
+    throw new Error(`Invalid regex pattern: ${error.message}`);
   }
 }
-
-// src/app/agent/tools/natives/async_command.ts
-import os2 from "os";
-import { spawn } from "child_process";
-import { v4 as uuidv42 } from "uuid";
-var runningCommands = /* @__PURE__ */ new Map();
-var MAX_OUTPUT_SIZE = 3e4;
-var MAX_STORED_COMMANDS = 50;
-var OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED - 30KB/200 lines max]";
-var DANGEROUS_PATTERNS = [
-  // Elevação de privilégios
-  /^sudo\s+/i,
-  /^doas\s+/i,
-  /^su\s+/i,
-  /^pkexec\s+/i,
-  /\|\s*sudo\s+/i,
-  /;\s*sudo\s+/i,
-  /&&\s*sudo\s+/i,
-  // Comandos destrutivos
-  /\brm\s+(-[rf]+\s+)*[\/~]/i,
-  /\brm\s+-[rf]*\s+\*/i,
-  /\bchmod\s+(777|666)\s+\//i,
-  /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i,
-  /\bmkfs\./i,
-  // Fork bombs
-  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
-  // Remote code exec
-  /\bcurl\s+.*\|\s*(ba)?sh/i,
-  /\bwget\s+.*\|\s*(ba)?sh/i
-];
-var INTERACTIVE_PATTERNS = [
-  /^(vim|vi|nano|emacs|pico)\s*/i,
-  /^(less|more|most)\s*/i,
-  /^(top|htop|btop|atop|nmon)\s*/i,
-  /^(ssh|telnet|ftp|sftp)\s+/i,
-  /^(mysql|psql|redis-cli|mongo|mongosh)\s*$/i,
-  /^(python|python3|node|ruby|irb|lua)\s*$/i,
-  /^(gdb|lldb)\s*/i
-];
-function cleanupOldCommands() {
-  if (runningCommands.size <= MAX_STORED_COMMANDS) return;
-  const commands = Array.from(runningCommands.entries()).filter(([_, cmd]) => cmd.status !== "running").sort((a, b) => (a[1].endTime || 0) - (b[1].endTime || 0));
-  const toRemove = commands.slice(0, commands.length - MAX_STORED_COMMANDS + 10);
-  for (const [id] of toRemove) {
-    runningCommands.delete(id);
+function matchesIncludePattern(filename, includePatterns) {
+  if (!includePatterns || includePatterns.length === 0) return true;
+  for (const pattern of includePatterns) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i");
+    if (regex.test(filename)) return true;
   }
+  return false;
 }
-function isDangerousCommand(command) {
-  const trimmed = command.trim();
-  for (const pattern of DANGEROUS_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
-    }
-  }
-  for (const pattern of INTERACTIVE_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return "Interactive commands are not supported in async mode";
+async function searchFile(filepath, baseDir, pattern, contextLines, matches, maxResults) {
+  let fileMatches = 0;
+  try {
+    const stats = await fsPromises2.stat(filepath);
+    if (stats.size > MAX_FILE_SIZE2) return 0;
+    const content = await fsPromises2.readFile(filepath, "utf-8");
+    const lines = content.split("\n");
+    const relativePath = path7.relative(baseDir, filepath);
+    for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
+      const line = lines[i];
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(line)) !== null && matches.length < maxResults) {
+        const lineContent = line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line;
+        const searchMatch = {
+          file: filepath,
+          relative_path: relativePath,
+          line_number: i + 1,
+          line_content: lineContent.trim(),
+          match_start: match.index,
+          match_end: match.index + match[0].length
+        };
+        if (contextLines > 0) {
+          searchMatch.context_before = lines.slice(Math.max(0, i - contextLines), i).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
+          searchMatch.context_after = lines.slice(i + 1, i + 1 + contextLines).map((l) => l.length > MAX_LINE_LENGTH ? l.substring(0, MAX_LINE_LENGTH) + "..." : l);
+        }
+        matches.push(searchMatch);
+        fileMatches++;
+        if (!pattern.global) break;
+      }
     }
+  } catch (error) {
   }
-  return null;
+  return fileMatches;
 }
-async function runCommandAsync(args) {
+async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats) {
+  if (matches.length >= maxResults) return;
+  let entries;
   try {
-    const {
-      command,
-      cwd = process.cwd(),
-      timeout = 0
-    } = args;
-    if (!command || typeof command !== "string") {
-      return {
-        success: false,
-        error: "command is required and must be a string"
-      };
-    }
-    const dangerReason = isDangerousCommand(command);
-    if (dangerReason) {
-      return {
-        success: false,
-        error: dangerReason
-      };
-    }
-    const commandId = uuidv42().substring(0, 8);
-    const platform = os2.platform();
-    let shellCmd;
-    let shellArgs;
-    if (platform === "win32") {
-      shellCmd = process.env.COMSPEC || "cmd.exe";
-      shellArgs = ["/c", command];
-    } else {
-      shellCmd = process.env.SHELL || "/bin/bash";
-      shellArgs = ["-c", command];
-    }
-    const entry = {
-      id: commandId,
-      command,
-      status: "running",
-      stdout: "",
-      stderr: "",
-      exitCode: null,
-      startTime: Date.now(),
-      process: null
-    };
-    const child = spawn(shellCmd, shellArgs, {
-      cwd,
-      env: process.env,
-      windowsHide: true
-    });
-    entry.process = child;
-    let stdoutTruncated = false;
-    child.stdout?.on("data", (data) => {
-      if (!stdoutTruncated) {
-        entry.stdout += data.toString();
-        if (entry.stdout.length > MAX_OUTPUT_SIZE) {
-          entry.stdout = entry.stdout.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
-          stdoutTruncated = true;
-        }
-      }
-    });
-    let stderrTruncated = false;
-    child.stderr?.on("data", (data) => {
-      if (!stderrTruncated) {
-        entry.stderr += data.toString();
-        if (entry.stderr.length > MAX_OUTPUT_SIZE) {
-          entry.stderr = entry.stderr.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MSG;
-          stderrTruncated = true;
-        }
-      }
-    });
-    child.on("close", (code) => {
-      entry.exitCode = code;
-      entry.status = code === 0 ? "completed" : "error";
-      entry.endTime = Date.now();
-      entry.process = null;
-    });
-    child.on("error", (error) => {
-      entry.stderr += `
-Process error: ${error.message}`;
-      entry.status = "error";
-      entry.endTime = Date.now();
-      entry.process = null;
-    });
-    if (timeout > 0) {
-      setTimeout(() => {
-        if (entry.status === "running") {
-          child.kill("SIGTERM");
-          setTimeout(() => {
-            if (entry.status === "running") {
-              child.kill("SIGKILL");
-            }
-          }, 2e3);
-          entry.status = "timeout";
-          entry.stderr += `
-Command timed out after ${timeout} seconds`;
-        }
-      }, timeout * 1e3);
+    entries = await fsPromises2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (matches.length >= maxResults) break;
+    const name = entry.name;
+    if (shouldIgnore2(name)) continue;
+    const fullPath = path7.join(dir, name);
+    if (entry.isDirectory()) {
+      await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats);
+    } else if (entry.isFile()) {
+      if (!isTextFile(name)) continue;
+      if (!matchesIncludePattern(name, includePatterns)) continue;
+      stats.filesSearched++;
+      const found = await searchFile(fullPath, baseDir, pattern, contextLines, matches, maxResults);
+      if (found > 0) stats.filesWithMatches++;
     }
-    runningCommands.set(commandId, entry);
-    cleanupOldCommands();
-    return {
-      success: true,
-      command_id: commandId,
-      command,
-      message: `Command started in background. Use command_status with id "${commandId}" to check progress.`
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Unexpected error: ${error.message}`
-    };
   }
 }
-async function commandStatus(args) {
+async function grepSearch(args) {
   try {
     const {
-      command_id,
-      wait_seconds = 0,
-      output_limit = 1e4
+      query,
+      path: searchPath,
+      case_insensitive = true,
+      is_regex = false,
+      include_patterns,
+      max_results = MAX_RESULTS3,
+      context_lines = 0
     } = args;
-    if (!command_id) {
+    if (!query || typeof query !== "string") {
       return {
         success: false,
-        command_id: "",
-        status: "error",
-        error: "command_id is required"
+        query: query || "",
+        search_path: searchPath || "",
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: "Query is required and must be a string"
       };
     }
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
+    if (!searchPath) {
       return {
         success: false,
-        command_id,
-        status: "not_found",
-        error: `Command with id "${command_id}" not found. It may have expired or never existed.`
+        query,
+        search_path: "",
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: "Search path is required"
       };
     }
-    if (wait_seconds > 0 && entry.status === "running") {
-      await new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          if (entry.status !== "running") {
-            clearInterval(checkInterval);
-            resolve();
-          }
-        }, 100);
-        setTimeout(() => {
-          clearInterval(checkInterval);
-          resolve();
-        }, wait_seconds * 1e3);
-      });
+    const resolvedPath = path7.resolve(searchPath);
+    let stats;
+    try {
+      stats = await fsPromises2.stat(resolvedPath);
+    } catch {
+      return {
+        success: false,
+        query,
+        search_path: resolvedPath,
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: `Path not found: ${resolvedPath}`
+      };
     }
-    let stdout = entry.stdout;
-    let stderr = entry.stderr;
-    let truncated = false;
-    if (stdout.length > output_limit) {
-      stdout = "..." + stdout.substring(stdout.length - output_limit);
-      truncated = true;
+    let pattern;
+    try {
+      pattern = createSearchPattern(query, is_regex, case_insensitive);
+    } catch (error) {
+      return {
+        success: false,
+        query,
+        search_path: resolvedPath,
+        matches: [],
+        files_searched: 0,
+        files_with_matches: 0,
+        total_matches: 0,
+        truncated: false,
+        error: error.message
+      };
     }
-    if (stderr.length > output_limit) {
-      stderr = "..." + stderr.substring(stderr.length - output_limit);
-      truncated = true;
+    const matches = [];
+    const searchStats = { filesSearched: 0, filesWithMatches: 0 };
+    if (stats.isDirectory()) {
+      await searchDirectory2(
+        resolvedPath,
+        resolvedPath,
+        pattern,
+        include_patterns,
+        context_lines,
+        matches,
+        max_results,
+        searchStats
+      );
+    } else if (stats.isFile()) {
+      searchStats.filesSearched = 1;
+      const found = await searchFile(resolvedPath, path7.dirname(resolvedPath), pattern, context_lines, matches, max_results);
+      if (found > 0) searchStats.filesWithMatches = 1;
+    }
+    return {
+      success: true,
+      query,
+      search_path: resolvedPath,
+      matches,
+      files_searched: searchStats.filesSearched,
+      files_with_matches: searchStats.filesWithMatches,
+      total_matches: matches.length,
+      truncated: matches.length >= max_results
+    };
+  } catch (error) {
+    return {
+      success: false,
+      query: args.query || "",
+      search_path: args.path || "",
+      matches: [],
+      files_searched: 0,
+      files_with_matches: 0,
+      total_matches: 0,
+      truncated: false,
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+
+// src/app/agent/tools/natives/view_file_outline.ts
+import path8 from "path";
+import { promises as fsPromises3 } from "fs";
+var LANGUAGE_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".java": "java",
+  ".go": "go",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".php": "php",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".scala": "scala"
+};
+var PATTERNS = {
+  typescript: [
+    // Classes
+    /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w,\s]+)?/,
+    // Interfaces
+    /^(?:export\s+)?interface\s+(\w+)/,
+    // Types
+    /^(?:export\s+)?type\s+(\w+)/,
+    // Functions (standalone)
+    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
+    // Arrow functions assigned to const/let
+    /^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+    // Methods inside classes (indented)
+    /^\s+(?:public|private|protected|static|async|readonly|\s)*(\w+)\s*\([^)]*\)\s*(?::\s*[\w<>\[\]|&\s]+)?\s*\{/,
+    // Const exports
+    /^(?:export\s+)?const\s+(\w+)\s*[:=]/
+  ],
+  javascript: [
+    /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/,
+    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
+    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+    /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/,
+    /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=/
+  ],
+  python: [
+    /^class\s+(\w+)(?:\([^)]*\))?:/,
+    /^(?:async\s+)?def\s+(\w+)\s*\(/,
+    /^(\w+)\s*=\s*(?:lambda|def)/
+  ],
+  java: [
+    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:abstract)?\s*class\s+(\w+)/,
+    /^(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*interface\s+(\w+)/,
+    /^\s*(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:synchronized)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
+  ],
+  go: [
+    /^type\s+(\w+)\s+struct\s*\{/,
+    /^type\s+(\w+)\s+interface\s*\{/,
+    /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/
+  ],
+  rust: [
+    /^(?:pub\s+)?struct\s+(\w+)/,
+    /^(?:pub\s+)?enum\s+(\w+)/,
+    /^(?:pub\s+)?trait\s+(\w+)/,
+    /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+    /^impl(?:<[^>]+>)?\s+(?:(\w+)|for\s+(\w+))/
+  ],
+  ruby: [
+    /^class\s+(\w+)/,
+    /^module\s+(\w+)/,
+    /^def\s+(\w+)/
+  ],
+  php: [
+    /^(?:abstract\s+)?class\s+(\w+)/,
+    /^interface\s+(\w+)/,
+    /^(?:public|private|protected)?\s*(?:static)?\s*function\s+(\w+)/
+  ],
+  csharp: [
+    /^(?:public|private|protected|internal)?\s*(?:static)?\s*(?:partial)?\s*class\s+(\w+)/,
+    /^(?:public|private|protected|internal)?\s*interface\s+(\w+)/,
+    /^\s*(?:public|private|protected|internal)?\s*(?:static)?\s*(?:async)?\s*(?:\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/
+  ],
+  swift: [
+    /^(?:public|private|internal|open)?\s*class\s+(\w+)/,
+    /^(?:public|private|internal)?\s*struct\s+(\w+)/,
+    /^(?:public|private|internal)?\s*protocol\s+(\w+)/,
+    /^(?:public|private|internal)?\s*(?:static)?\s*func\s+(\w+)/
+  ],
+  kotlin: [
+    /^(?:open|abstract|sealed)?\s*class\s+(\w+)/,
+    /^interface\s+(\w+)/,
+    /^(?:private|public|internal)?\s*fun\s+(\w+)/
+  ],
+  scala: [
+    /^(?:sealed\s+)?(?:abstract\s+)?class\s+(\w+)/,
+    /^object\s+(\w+)/,
+    /^trait\s+(\w+)/,
+    /^def\s+(\w+)/
+  ],
+  c: [
+    /^(?:static\s+)?(?:inline\s+)?(?:const\s+)?(?:\w+(?:\s*\*)*)\s+(\w+)\s*\([^)]*\)\s*\{/,
+    /^typedef\s+struct\s*\w*\s*\{[^}]*\}\s*(\w+)/,
+    /^struct\s+(\w+)\s*\{/
+  ],
+  cpp: [
+    /^class\s+(\w+)/,
+    /^(?:virtual\s+)?(?:\w+(?:\s*[*&])*)\s+(\w+)\s*\([^)]*\)\s*(?:const)?\s*(?:override)?\s*\{/,
+    /^namespace\s+(\w+)\s*\{/
+  ]
+};
+function detectLanguage(filepath) {
+  const ext = path8.extname(filepath).toLowerCase();
+  return LANGUAGE_MAP[ext] || "unknown";
+}
+function determineItemType(line, language) {
+  const normalizedLine = line.trim().toLowerCase();
+  if (normalizedLine.includes("class ")) return "class";
+  if (normalizedLine.includes("interface ")) return "interface";
+  if (normalizedLine.includes("type ")) return "type";
+  if (normalizedLine.startsWith("import ")) return "import";
+  if (normalizedLine.includes("export ") && !normalizedLine.includes("function") && !normalizedLine.includes("class")) return "export";
+  if (line.startsWith("  ") || line.startsWith("	")) {
+    if (normalizedLine.includes("function") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
+      return "method";
     }
-    const duration = entry.endTime ? (entry.endTime - entry.startTime) / 1e3 : (Date.now() - entry.startTime) / 1e3;
-    return {
-      success: true,
-      command_id,
-      status: entry.status,
-      stdout: stdout || void 0,
-      stderr: stderr || void 0,
-      exit_code: entry.exitCode,
-      duration_seconds: Math.round(duration * 10) / 10,
-      truncated
-    };
-  } catch (error) {
-    return {
-      success: false,
-      command_id: args.command_id || "",
-      status: "error",
-      error: `Unexpected error: ${error.message}`
-    };
+    if (/^\s+\w+\s*\(/.test(line)) return "method";
+  }
+  if (normalizedLine.includes("function ") || normalizedLine.includes("def ") || normalizedLine.includes("fn ") || normalizedLine.includes("func ")) {
+    return "function";
+  }
+  if (normalizedLine.includes("const ") || normalizedLine.includes("let ") || normalizedLine.includes("var ")) {
+    return normalizedLine.includes("=>") ? "function" : "const";
   }
+  return "function";
 }
-async function sendCommandInput(args) {
-  try {
-    const { command_id, input } = args;
-    if (!command_id || input === void 0) {
-      return {
-        success: false,
-        error: "command_id and input are required"
-      };
-    }
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
-      return {
-        success: false,
-        error: `Command with id "${command_id}" not found`
-      };
+async function extractOutline(filepath, content, language) {
+  const items = [];
+  const lines = content.split("\n");
+  const patterns = PATTERNS[language] || PATTERNS.javascript;
+  let currentClass = null;
+  let braceCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const openBraces = (line.match(/\{/g) || []).length;
+    const closeBraces = (line.match(/\}/g) || []).length;
+    braceCount += openBraces - closeBraces;
+    if (braceCount <= 0 && currentClass) {
+      currentClass = null;
     }
-    if (entry.status !== "running" || !entry.process) {
-      return {
-        success: false,
-        error: `Command is not running (status: ${entry.status})`
-      };
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const name = match[1] || match[2];
+        if (!name) continue;
+        const itemType = determineItemType(line, language);
+        if (!itemType) continue;
+        const exported = line.includes("export ");
+        const isInsideClass = currentClass && (line.startsWith("  ") || line.startsWith("	"));
+        const item = {
+          type: itemType,
+          name,
+          line_start: lineNumber,
+          signature: line.trim().substring(0, 120),
+          exported
+        };
+        if (isInsideClass && itemType === "method" && currentClass) {
+          item.parent = currentClass;
+        }
+        if (itemType === "class") {
+          currentClass = name;
+        }
+        items.push(item);
+        break;
+      }
     }
-    entry.process.stdin?.write(input);
-    return {
-      success: true,
-      message: `Sent ${input.length} characters to command ${command_id}`
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `Failed to send input: ${error.message}`
-    };
   }
+  return items;
 }
-async function killCommand(args) {
+function generateSummary(items, totalLines) {
+  const counts = {};
+  for (const item of items) {
+    counts[item.type] = (counts[item.type] || 0) + 1;
+  }
+  const parts = [`${totalLines} lines`];
+  if (counts.class) parts.push(`${counts.class} class${counts.class > 1 ? "es" : ""}`);
+  if (counts.interface) parts.push(`${counts.interface} interface${counts.interface > 1 ? "s" : ""}`);
+  if (counts.function) parts.push(`${counts.function} function${counts.function > 1 ? "s" : ""}`);
+  if (counts.method) parts.push(`${counts.method} method${counts.method > 1 ? "s" : ""}`);
+  if (counts.type) parts.push(`${counts.type} type${counts.type > 1 ? "s" : ""}`);
+  if (counts.const) parts.push(`${counts.const} const${counts.const > 1 ? "s" : ""}`);
+  return parts.join(", ");
+}
+async function viewFileOutline(args) {
   try {
-    const { command_id } = args;
-    const entry = runningCommands.get(command_id);
-    if (!entry) {
+    const { file_path } = args;
+    if (!file_path || typeof file_path !== "string") {
       return {
         success: false,
-        error: `Command with id "${command_id}" not found`
+        file_path: file_path || "",
+        language: "unknown",
+        total_lines: 0,
+        items: [],
+        summary: "",
+        error: "file_path is required and must be a string"
       };
     }
-    if (entry.status !== "running" || !entry.process) {
+    const resolvedPath = path8.resolve(file_path);
+    let content;
+    try {
+      content = await fsPromises3.readFile(resolvedPath, "utf-8");
+    } catch (error) {
       return {
         success: false,
-        error: `Command is not running (status: ${entry.status})`
+        file_path: resolvedPath,
+        language: "unknown",
+        total_lines: 0,
+        items: [],
+        summary: "",
+        error: error.code === "ENOENT" ? `File not found: ${resolvedPath}` : `Error reading file: ${error.message}`
       };
     }
-    entry.process.kill("SIGTERM");
-    entry.status = "killed";
-    entry.endTime = Date.now();
+    const language = detectLanguage(resolvedPath);
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const items = await extractOutline(resolvedPath, content, language);
     return {
       success: true,
-      message: `Command ${command_id} killed`
+      file_path: resolvedPath,
+      language,
+      total_lines: totalLines,
+      items,
+      summary: generateSummary(items, totalLines)
     };
   } catch (error) {
     return {
       success: false,
-      error: `Failed to kill command: ${error.message}`
+      file_path: args.file_path || "",
+      language: "unknown",
+      total_lines: 0,
+      items: [],
+      summary: "",
+      error: `Unexpected error: ${error.message}`
     };
   }
 }
 
+// src/app/agent/tool_invoker.ts
+init_async_command();
+
 // src/app/agent/tools/natives/task_boundary.ts
 import path9 from "path";
 import { promises as fs7 } from "fs";
@@ -3066,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 });
@@ -3388,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.
@@ -3431,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.
@@ -3667,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";
@@ -3804,39 +3709,209 @@ async function doSaveSessionHistory(sessionFile, history) {
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
-      try {
-        await fs10.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
-      } catch {
+      try {
+        await fs10.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      } catch {
+      }
+    }
+    sessionData.conversation_history = history;
+    sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+    const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
+    try {
+      await fs10.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await safeRenameWithRetry(tempSessionFile, sessionFile);
+    } catch (writeError) {
+      if (writeError instanceof Error) {
+        console.error(`Fatal error saving session to ${sessionFile}: ${writeError.message}`);
+      } else {
+        console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
+      }
+      try {
+        await fs10.unlink(tempSessionFile);
+      } catch {
+      }
+    }
+  });
+}
+async function saveSessionHistory(sessionFile, history) {
+  debouncedSave(sessionFile, history);
+}
+
+// src/app/agent/core/prompt/prompt_builder.ts
+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 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;
       }
     }
-    sessionData.conversation_history = history;
-    sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
-    const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
+    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 {
-      await fs10.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
-      await safeRenameWithRetry(tempSessionFile, sessionFile);
-    } catch (writeError) {
-      if (writeError instanceof Error) {
-        console.error(`Fatal error saving session to ${sessionFile}: ${writeError.message}`);
-      } else {
-        console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
+      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;
       }
-      try {
-        await fs10.unlink(tempSessionFile);
-      } catch {
+    }
+    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;
       }
     }
-  });
-}
-async function saveSessionHistory(sessionFile, history) {
-  debouncedSave(sessionFile, history);
-}
+    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
-import os6 from "os";
-import fs11 from "fs";
-import path13 from "path";
-import { execSync } from "child_process";
 function getNodeVersion() {
   try {
     return process.version;
@@ -3864,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";
@@ -3875,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";
@@ -3896,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";
@@ -3907,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";
@@ -3915,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`;
     }
@@ -3985,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)
@@ -3996,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.
+### Testing Philosophy:
+Run tests when modifying code. Use the \`testing\` skill for detailed best practices.
 
-**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
-
-**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>
 
 ---
@@ -4029,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
@@ -4081,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:**
@@ -4110,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" }
@@ -4119,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):**
@@ -4164,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>
 
 ---
 
@@ -4233,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",
@@ -4253,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;
   }
@@ -4317,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;
@@ -4328,6 +4675,7 @@ var BluMaAgent = class {
   eventBus;
   mcpClient;
   feedbackSystem;
+  skillLoader;
   maxContextTurns = 30;
   isInterrupted = false;
   constructor(sessionId2, eventBus2, llm, deploymentName, mcpClient, feedbackSystem) {
@@ -4337,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" });
@@ -4348,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}` });
@@ -4360,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);
     }
@@ -4376,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) {
@@ -4474,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.";
@@ -4503,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}`;
@@ -4529,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) {
@@ -4552,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));
@@ -4573,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 {
@@ -4596,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,
@@ -4613,6 +4986,12 @@ var OpenAIAdapter = class {
     });
     return resp;
   }
+  /**
+   * Retorna o modelo padrão configurado
+   */
+  getDefaultModel() {
+    return this.defaultModel;
+  }
 };
 
 // src/app/agent/subagents/registry.ts
@@ -4627,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
@@ -4641,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:
@@ -4766,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.
@@ -4781,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
 
@@ -4790,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",
@@ -4886,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." });
       }
@@ -5047,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;
@@ -5070,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
     );
@@ -5147,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();
@@ -5163,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);
@@ -5265,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
     ] })
   ] });
 };
@@ -5401,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: [
@@ -5411,7 +5790,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs8(Text8, { children: [
       " ",
-      path17
+      path18
     ] })
   ] });
 };
@@ -5479,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);
@@ -5503,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 }));
@@ -5710,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 }) });
@@ -5797,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;
   }
@@ -5998,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 };
@@ -6015,7 +6423,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path16.dirname(dir);
+    const parent = path17.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6028,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) {
@@ -6079,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
   ] });
 };
@@ -6092,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: ",
@@ -6134,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",
@@ -6219,6 +6627,61 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         ]);
         return;
       }
+      if (text.startsWith("!")) {
+        const command = text.slice(1).trim();
+        if (!command) {
+          setIsProcessing(false);
+          return;
+        }
+        setHistory((prev) => [
+          ...prev,
+          {
+            id: prev.length,
+            component: /* @__PURE__ */ jsxs15(Box16, { marginBottom: 1, children: [
+              /* @__PURE__ */ jsx16(Text15, { color: "white", bold: true, children: "$ " }),
+              /* @__PURE__ */ jsx16(Text15, { color: "white", children: command })
+            ] })
+          }
+        ]);
+        Promise.resolve().then(() => (init_async_command(), async_command_exports)).then(async ({ runCommandAsync: runCommandAsync2 }) => {
+          try {
+            const result = await runCommandAsync2({ command, cwd: workdir });
+            if (result.success && result.command_id) {
+              const contextMessage = `[User executed shell command directly]
+Command: ${command}
+Command ID: ${result.command_id}
+
+Please use command_status to check the result and report back to the user.`;
+              agentInstance.current?.processTurn({ content: contextMessage });
+            } else {
+              setHistory((prev) => [
+                ...prev,
+                {
+                  id: prev.length,
+                  component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                    "Failed to execute: ",
+                    result.error || result.message
+                  ] })
+                }
+              ]);
+              setIsProcessing(false);
+            }
+          } catch (err) {
+            setHistory((prev) => [
+              ...prev,
+              {
+                id: prev.length,
+                component: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+                  "Error: ",
+                  err.message
+                ] })
+              }
+            ]);
+            setIsProcessing(false);
+          }
+        });
+        return;
+      }
       setIsProcessing(true);
       const displayText = text.length > 1e4 ? text.substring(0, 1e4) + "..." : text;
       setHistory((prev) => [