@nomad-e/bluma-cli 0.0.103 → 0.0.104

package/dist/main.js

@@ -159,43 +159,85 @@ var init_tool_call_normalizer = __esm({
 });
 
 // src/main.ts
-import React6 from "react";
+import React10 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter2 } from "events";
-import { v4 as uuidv42 } from "uuid";
+import { v4 as uuidv43 } from "uuid";
 
 // src/app/ui/App.tsx
-import { useState as useState5, useEffect as useEffect5, useRef as useRef4, useCallback as useCallback2, memo as memo5 } from "react";
-import { Box as Box15, Text as Text14, Static } from "ink";
+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 Header = ({
+var VERSION = "0.0.103";
+var HeaderComponent = ({
   sessionId: sessionId2,
   workdir
 }) => {
+  const dirName = workdir.split("/").pop() || workdir;
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx(Text, { bold: true, color: "magenta", children: "BluMa" }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2022 AI Coding Assistant" })
-    ] }),
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "workspace " }),
-        /* @__PURE__ */ jsx(Text, { color: "cyan", children: workdir })
-      ] }),
-      /* @__PURE__ */ jsxs(Box, { marginTop: 0, children: [
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "session " }),
-        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-          sessionId2.slice(0, 8),
-          "..."
-        ] })
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "magenta", children: "bluma" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " ",
+        VERSION
       ] })
     ] }),
-    /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "/init  /tools  /mcp  /clear  /help" }) })
+    /* @__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";
@@ -479,7 +521,7 @@ var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
 };
 
 // src/app/ui/components/InputPrompt.tsx
-import { useEffect as useEffect3, useMemo, useState as useState2, memo } from "react";
+import { useEffect as useEffect3, useMemo, useState as useState2, memo as memo2 } from "react";
 import { EventEmitter } from "events";
 
 // src/app/ui/utils/slashRegistry.ts
@@ -683,7 +725,7 @@ function useAtCompletion({
 import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var uiEventBus = global.__bluma_ui_eventbus__ || new EventEmitter();
 global.__bluma_ui_eventbus__ = uiEventBus;
-var TextLine = memo(({
+var TextLine = memo2(({
   line,
   lineIndex,
   cursorLine,
@@ -712,7 +754,7 @@ var TextLine = memo(({
   return true;
 });
 TextLine.displayName = "TextLine";
-var PathSuggestions = memo(({
+var PathSuggestions = memo2(({
   suggestions,
   selected
 }) => {
@@ -732,7 +774,7 @@ var PathSuggestions = memo(({
   }) });
 });
 PathSuggestions.displayName = "PathSuggestions";
-var SlashSuggestions = memo(({
+var SlashSuggestions = memo2(({
   suggestions,
   selectedIndex
 }) => /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: suggestions.map((s, idx) => {
@@ -750,9 +792,9 @@ var SlashSuggestions = memo(({
   ] }, s.name);
 }) }));
 SlashSuggestions.displayName = "SlashSuggestions";
-var Footer = memo(({ isReadOnly }) => /* @__PURE__ */ jsx2(Box2, { paddingX: 1, justifyContent: "center", children: /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: isReadOnly ? "ctrl+c to exit | Enter to send message | Shift+Enter for new line | esc interrupt" : "ctrl+c to exit | Enter to submit | Shift+Enter for new line | /help commands | esc interrupt" }) }));
+var Footer = memo2(({ isReadOnly }) => /* @__PURE__ */ jsx2(Box2, { paddingX: 1, justifyContent: "center", children: /* @__PURE__ */ jsx2(Text2, { color: "gray", dimColor: true, children: isReadOnly ? "ctrl+c to exit | Enter to send message | Shift+Enter for new line | esc interrupt" : "ctrl+c to exit | Enter to submit | Shift+Enter for new line | /help commands | esc interrupt" }) }));
 Footer.displayName = "Footer";
-var TextLinesRenderer = memo(({
+var TextLinesRenderer = memo2(({
   lines,
   cursorLine,
   cursorCol,
@@ -785,7 +827,7 @@ var TextLinesRenderer = memo(({
   }) });
 });
 TextLinesRenderer.displayName = "TextLinesRenderer";
-var InputPrompt = memo(({
+var InputPrompt = memo2(({
   onSubmit,
   isReadOnly,
   onInterrupt,
@@ -951,77 +993,55 @@ var InputPrompt = memo(({
 InputPrompt.displayName = "InputPrompt";
 
 // src/app/ui/ConfirmationPrompt.tsx
+import { memo as memo4 } from "react";
 import { Box as Box6, Text as Text6 } from "ink";
 
 // src/app/ui/InteractiveMenu.tsx
-import { useState as useState3, memo as memo2 } from "react";
+import { useState as useState3, memo as memo3 } from "react";
 import { Box as Box3, Text as Text3, useInput as useInput3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var InteractiveMenuComponent = ({ onDecision }) => {
   const options = [
-    {
-      key: "y",
-      label: "Accept",
-      value: "accept",
-      color: "green"
-    },
-    {
-      key: "n",
-      label: "Decline",
-      value: "decline",
-      color: "red"
-    },
-    {
-      key: "a",
-      label: "Always Accept",
-      value: "accept_always",
-      color: "yellow"
-    }
+    { key: "y", label: "yes", value: "accept", color: "green" },
+    { key: "n", label: "no", value: "decline", color: "red" },
+    { key: "a", label: "always", value: "accept_always", color: "yellow" }
   ];
-  const [selectedOption, setSelectedOption] = useState3(0);
+  const [selected, setSelected] = useState3(0);
   useInput3((input, key) => {
-    if (key.upArrow) {
-      setSelectedOption((prev) => prev > 0 ? prev - 1 : options.length - 1);
+    if (key.upArrow || key.leftArrow) {
+      setSelected((i) => i > 0 ? i - 1 : options.length - 1);
     }
-    if (key.downArrow) {
-      setSelectedOption((prev) => prev < options.length - 1 ? prev + 1 : 0);
+    if (key.downArrow || key.rightArrow) {
+      setSelected((i) => i < options.length - 1 ? i + 1 : 0);
     }
     if (key.escape) {
       onDecision("decline");
     }
     if (key.return) {
-      onDecision(options[selectedOption].value);
+      onDecision(options[selected].value);
     }
-    const option = options.find((opt) => opt.key === input.toLowerCase());
-    if (option) {
-      onDecision(option.value);
+    const opt = options.find((o) => o.key === input.toLowerCase());
+    if (opt) {
+      onDecision(opt.value);
     }
   });
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Authorize this action?" }) }),
-    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", paddingLeft: 1, children: options.map((option, index) => {
-      const isSelected = selectedOption === index;
-      return /* @__PURE__ */ jsxs3(Box3, { marginBottom: 0, children: [
-        /* @__PURE__ */ jsx3(Text3, { color: isSelected ? "magenta" : "gray", children: isSelected ? "\u25B8 " : "  " }),
-        /* @__PURE__ */ jsxs3(
-          Text3,
-          {
-            color: isSelected ? option.color : "gray",
-            bold: isSelected,
-            children: [
-              "[",
-              option.key,
-              "] ",
-              option.label
-            ]
-          }
-        )
-      ] }, option.value);
-    }) }),
-    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, paddingLeft: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2191\u2193 to select \u2022 Enter to confirm \u2022 Esc to cancel" }) })
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "approve? " }),
+      options.map((opt, idx) => {
+        const isSelected = idx === selected;
+        return /* @__PURE__ */ jsx3(Box3, { marginRight: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: isSelected ? opt.color : "gray", bold: isSelected, children: [
+          "[",
+          opt.key,
+          "]",
+          opt.label
+        ] }) }, opt.value);
+      })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "arrows to select, enter to confirm, esc to cancel" }) })
   ] });
 };
-var InteractiveMenu = memo2(InteractiveMenuComponent);
+var InteractiveMenu = memo3(InteractiveMenuComponent);
 
 // src/app/ui/components/promptRenderers.tsx
 import { Box as Box5, Text as Text5 } from "ink";
@@ -1171,7 +1191,7 @@ var renderEditTool = ({ toolCall, preview }) => {
 var renderGeneric = ({ toolCall }) => {
   const toolName = toolCall.function.name;
   const rawArguments = toolCall.function.arguments;
-  const MAX_LINES = 5;
+  const MAX_LINES2 = 5;
   let formattedArgsString;
   if (!rawArguments) {
     formattedArgsString = "";
@@ -1186,9 +1206,9 @@ var renderGeneric = ({ toolCall }) => {
     formattedArgsString = JSON.stringify(rawArguments, null, 2);
   }
   const lines = formattedArgsString.split("\n");
-  const isTruncated = lines.length > MAX_LINES;
-  const visibleLines = isTruncated ? lines.slice(0, MAX_LINES) : lines;
-  const remainingCount = lines.length - MAX_LINES;
+  const isTruncated = lines.length > MAX_LINES2;
+  const visibleLines = isTruncated ? lines.slice(0, MAX_LINES2) : lines;
+  const remainingCount = lines.length - MAX_LINES2;
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
     /* @__PURE__ */ jsxs5(Box5, { children: [
       /* @__PURE__ */ jsx5(Text5, { color: "blue", children: "\u25B8" }),
@@ -1285,45 +1305,64 @@ var promptRenderers = {
 
 // src/app/ui/ConfirmationPrompt.tsx
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
-var ConfirmationPrompt = ({ toolCalls, preview, onDecision }) => {
+var ConfirmationPromptComponent = ({ toolCalls, preview, onDecision }) => {
   const toolCall = toolCalls && toolCalls.length > 0 ? toolCalls[0] : null;
   if (!toolCall) {
-    return /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "Waiting for a valid command to confirm..." }) });
+    return /* @__PURE__ */ jsx6(Box6, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "waiting..." }) });
   }
   const toolName = toolCall.function.name;
   const renderFunction = promptRenderers[toolName] || renderGeneric;
-  return (
-    // A "MOLDURA" COMUM A TODOS OS PROMPTS
-    /* @__PURE__ */ jsxs6(
-      Box6,
-      {
-        borderStyle: "round",
-        borderColor: "gray",
-        flexDirection: "column",
-        paddingX: 1,
-        children: [
-          renderFunction({ toolCall, preview }),
-          /* @__PURE__ */ jsx6(InteractiveMenu, { onDecision })
-        ]
-      }
-    )
-  );
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, children: [
+    renderFunction({ toolCall, preview }),
+    /* @__PURE__ */ jsx6(InteractiveMenu, { onDecision })
+  ] });
 };
+var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import OpenAI from "openai";
 import * as dotenv from "dotenv";
-import path10 from "path";
-import os7 from "os";
+import path15 from "path";
+import os9 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs6 } from "fs";
-import path5 from "path";
+import { promises as fs8 } from "fs";
+import path10 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/agent/tools/natives/shell_command.ts
 import os from "os";
 import { spawn } from "child_process";
+var MAX_OUTPUT_SIZE = 1e5;
+var OUTPUT_TRUNCATION_MESSAGE = "\n\n[OUTPUT TRUNCATED - exceeded 100KB limit. Use pagination or redirect to file for full output.]";
+var DANGEROUS_PATTERNS = [
+  /^sudo\s+/i,
+  // sudo commands
+  /^doas\s+/i,
+  // doas (BSD sudo alternative)
+  /^su\s+/i,
+  // switch user
+  /^pkexec\s+/i,
+  // PolicyKit execution
+  /\|\s*sudo\s+/i,
+  // piped to sudo
+  /;\s*sudo\s+/i,
+  // chained with sudo
+  /&&\s*sudo\s+/i
+  // AND chained with sudo
+];
+var INTERACTIVE_PATTERNS = [
+  /^(vim|vi|nano|emacs|less|more)\s*/i,
+  // editors/pagers
+  /^(top|htop|btop)\s*/i,
+  // monitoring tools
+  /^(ssh|telnet|ftp)\s+/i,
+  // remote connections
+  /^(mysql|psql|redis-cli|mongo)\s*/i,
+  // database CLIs
+  /^(python|node|ruby|irb)\s*$/i
+  // REPLs without script
+];
 function shellCommand(args) {
   const {
     command,
@@ -1335,6 +1374,45 @@ function shellCommand(args) {
   return new Promise((resolve) => {
     const startTime = Date.now();
     const platform = os.platform();
+    const commandTrimmed = command.trim();
+    for (const pattern of DANGEROUS_PATTERNS) {
+      if (pattern.test(commandTrimmed)) {
+        const result = {
+          status: "blocked",
+          exitCode: null,
+          stdout: "",
+          stderr: `Command blocked: "${commandTrimmed}" requires elevated privileges (sudo/doas). These commands require interactive password input which cannot be handled. Alternatives:
+1. Run the command manually in terminal
+2. Configure passwordless sudo for this specific command
+3. Run BluMa as root (not recommended)`,
+          command,
+          cwd,
+          platform,
+          duration: Date.now() - startTime,
+          blockedReason: "requires_sudo"
+        };
+        return resolve(formatResult(result, verbose));
+      }
+    }
+    for (const pattern of INTERACTIVE_PATTERNS) {
+      if (pattern.test(commandTrimmed)) {
+        const result = {
+          status: "blocked",
+          exitCode: null,
+          stdout: "",
+          stderr: `Command blocked: "${commandTrimmed}" is an interactive command. Interactive commands require user input and cannot be handled by the agent. Alternatives:
+1. Use non-interactive alternatives (e.g., 'cat' instead of 'less')
+2. Run the command manually in terminal
+3. For editors, use edit_tool instead`,
+          command,
+          cwd,
+          platform,
+          duration: Date.now() - startTime,
+          blockedReason: "interactive_command"
+        };
+        return resolve(formatResult(result, verbose));
+      }
+    }
     let shellCmd;
     let shellArgs;
     if (platform === "win32") {
@@ -1346,6 +1424,8 @@ function shellCommand(args) {
     }
     let stdout = "";
     let stderr = "";
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
     let timedOut = false;
     let finished = false;
     const childProcess = spawn(shellCmd, shellArgs, {
@@ -1367,12 +1447,24 @@ function shellCommand(args) {
     }, timeout * 1e3);
     if (childProcess.stdout) {
       childProcess.stdout.on("data", (data) => {
-        stdout += data.toString();
+        if (!stdoutTruncated) {
+          stdout += data.toString();
+          if (stdout.length > MAX_OUTPUT_SIZE) {
+            stdout = stdout.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MESSAGE;
+            stdoutTruncated = true;
+          }
+        }
       });
     }
     if (childProcess.stderr) {
       childProcess.stderr.on("data", (data) => {
-        stderr += data.toString();
+        if (!stderrTruncated) {
+          stderr += data.toString();
+          if (stderr.length > MAX_OUTPUT_SIZE) {
+            stderr = stderr.substring(0, MAX_OUTPUT_SIZE) + OUTPUT_TRUNCATION_MESSAGE;
+            stderrTruncated = true;
+          }
+        }
       });
     }
     childProcess.on("error", (error) => {
@@ -1405,7 +1497,8 @@ ${stderr.trim()}` : stderr.trim(),
           command,
           cwd,
           platform,
-          duration: Date.now() - startTime
+          duration: Date.now() - startTime,
+          truncated: stdoutTruncated || stderrTruncated
         };
         resolve(formatResult(result, verbose));
       }
@@ -1429,6 +1522,12 @@ function formatResult(result, verbose) {
   if (result.status === "timeout") {
     output.message = `Command exceeded timeout of ${result.duration / 1e3}s`;
   }
+  if (result.status === "blocked" && result.blockedReason) {
+    output.blockedReason = result.blockedReason;
+  }
+  if (result.truncated) {
+    output.warning = "Output was truncated due to size limits (100KB max per stream)";
+  }
   return JSON.stringify(output, null, 2);
 }
 
@@ -1464,12 +1563,19 @@ function unescapeLlmString(inputString) {
     return inputString;
   }
 }
-function replaceAllOccurrences(text, search, replacement) {
-  if (search === "") return text;
-  if (typeof text.replaceAll === "function") {
-    return text.replaceAll(search, replacement);
+function replaceNOccurrences(text, search, replacement, count) {
+  if (search === "" || count <= 0) return text;
+  let result = text;
+  let replaced = 0;
+  let lastIndex = 0;
+  while (replaced < count) {
+    const index = result.indexOf(search, lastIndex);
+    if (index === -1) break;
+    result = result.substring(0, index) + replacement + result.substring(index + search.length);
+    lastIndex = index + replacement.length;
+    replaced++;
   }
-  return text.split(search).join(replacement);
+  return result;
 }
 function countOccurrences(text, search) {
   if (search === "" || text === "") return 0;
@@ -1483,10 +1589,63 @@ function ensureCorrectEdit(currentContent, originalOldString, originalNewString,
     return [finalOldString, finalNewString, occurrences];
   }
   const candidates = [
-    { old: unescapeLlmString(originalOldString), new: unescapeLlmString(originalNewString) },
-    { old: originalOldString.trim(), new: originalNewString.trim() },
-    { old: unescapeLlmString(originalOldString).trim(), new: unescapeLlmString(originalNewString).trim() }
+    {
+      old: unescapeLlmString(originalOldString),
+      new: unescapeLlmString(originalNewString),
+      strategy: "unescape_llm"
+    },
+    {
+      old: originalOldString.trim(),
+      new: originalNewString.trim(),
+      strategy: "trim"
+    },
+    {
+      old: unescapeLlmString(originalOldString).trim(),
+      new: unescapeLlmString(originalNewString).trim(),
+      strategy: "unescape_and_trim"
+    }
   ];
+  const oldWithoutTrailing = originalOldString.split("\n").map((l) => l.trimEnd()).join("\n");
+  const newWithoutTrailing = originalNewString.split("\n").map((l) => l.trimEnd()).join("\n");
+  if (oldWithoutTrailing !== originalOldString) {
+    candidates.push({
+      old: oldWithoutTrailing,
+      new: newWithoutTrailing,
+      strategy: "trim_trailing"
+    });
+  }
+  const oldTabsToSpaces = originalOldString.replace(/\t/g, "  ");
+  const oldSpacesToTabs = originalOldString.replace(/  /g, "	");
+  if (oldTabsToSpaces !== originalOldString) {
+    candidates.push({
+      old: oldTabsToSpaces,
+      new: originalNewString.replace(/\t/g, "  "),
+      strategy: "tabs_to_spaces"
+    });
+  }
+  if (oldSpacesToTabs !== originalOldString) {
+    candidates.push({
+      old: oldSpacesToTabs,
+      new: originalNewString.replace(/  /g, "	"),
+      strategy: "spaces_to_tabs"
+    });
+  }
+  const old2to4 = originalOldString.replace(/^( {2})/gm, "    ");
+  const old4to2 = originalOldString.replace(/^( {4})/gm, "  ");
+  if (old2to4 !== originalOldString) {
+    candidates.push({
+      old: old2to4,
+      new: originalNewString.replace(/^( {2})/gm, "    "),
+      strategy: "indent_2_to_4"
+    });
+  }
+  if (old4to2 !== originalOldString) {
+    candidates.push({
+      old: old4to2,
+      new: originalNewString.replace(/^( {4})/gm, "  "),
+      strategy: "indent_4_to_2"
+    });
+  }
   for (const candidate of candidates) {
     if (candidate.old === originalOldString) continue;
     const candidateOccurrences = countOccurrences(currentContent, candidate.old);
@@ -1585,7 +1744,7 @@ ${contentPreview}${currentContent.length > 500 ? "..." : ""}`,
     if (isNewFile) {
       newContentResult = normalizedNewString;
     } else if (currentContent !== null) {
-      newContentResult = replaceAllOccurrences(currentContent, normalizedOldString, normalizedNewString);
+      newContentResult = replaceNOccurrences(currentContent, normalizedOldString, normalizedNewString, expectedReplacements);
     }
   }
   return { currentContent, newContent: newContentResult, occurrences, error, isNewFile };
@@ -1652,10 +1811,11 @@ async function editTool(args) {
         file_path
       };
     }
-    if (normalizedFilePath.includes("..")) {
+    const cwd = process.cwd();
+    if (!normalizedFilePath.startsWith(cwd) && !path3.isAbsolute(file_path)) {
       return {
         success: false,
-        error: `Invalid parameters: file_path cannot contain '..'.`,
+        error: `Invalid parameters: file_path must be within the current working directory or be an absolute path.`,
         file_path: normalizedFilePath
       };
     }
@@ -1873,151 +2033,1652 @@ async function countLines(args) {
 }
 
 // src/app/agent/tools/natives/todo.ts
-async function todo({ tasks }) {
-  const todos = tasks.map((task, index) => ({
-    id: index + 1,
-    description: task.description,
-    isComplete: task.isComplete
-  }));
-  return todos;
+import * as fs6 from "fs";
+import * as path5 from "path";
+var taskStore = [];
+var nextId = 1;
+function getTodoFilePath() {
+  return path5.join(process.cwd(), ".bluma", "todo.json");
 }
-
-// src/app/agent/tool_invoker.ts
-var ToolInvoker = class {
-  // Mapa privado para associar nomes de ferramentas às suas funções de implementação.
-  toolImplementations;
-  // Propriedade privada para armazenar as definições de ferramentas carregadas do JSON.
-  toolDefinitions = [];
-  constructor() {
-    this.toolImplementations = /* @__PURE__ */ new Map();
-    this.registerTools();
+function loadTasksFromFile() {
+  try {
+    const filePath = getTodoFilePath();
+    if (fs6.existsSync(filePath)) {
+      const data = fs6.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (Array.isArray(parsed.tasks)) {
+        taskStore = parsed.tasks;
+        nextId = parsed.nextId || taskStore.length + 1;
+      }
+    }
+  } catch {
   }
-  /**
-   * Carrega as definições de ferramentas do arquivo de configuração `native_tools.json`.
-   * Este método é assíncrono e deve ser chamado após a criação da instância.
-   */
-  async initialize() {
-    try {
-      const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path5.dirname(__filename);
-      const configPath = path5.resolve(__dirname, "config", "native_tools.json");
-      const fileContent = await fs6.readFile(configPath, "utf-8");
-      const config2 = JSON.parse(fileContent);
-      this.toolDefinitions = config2.nativeTools;
-    } catch (error) {
-      console.error("[ToolInvoker] Erro cr\xEDtico ao carregar 'native_tools.json'. As ferramentas nativas n\xE3o estar\xE3o dispon\xEDveis.", error);
-      this.toolDefinitions = [];
+}
+function saveTasksToFile() {
+  try {
+    const filePath = getTodoFilePath();
+    const dir = path5.dirname(filePath);
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
     }
+    fs6.writeFileSync(filePath, JSON.stringify({
+      tasks: taskStore,
+      nextId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2));
+  } catch {
   }
-  /**
-   * Registra as implementações de todas as ferramentas nativas.
-   * Este método mapeia o nome da ferramenta (string) para a função TypeScript que a executa.
-   */
-  registerTools() {
-    this.toolImplementations.set("shell_command", shellCommand);
-    this.toolImplementations.set("edit_tool", editTool);
-    this.toolImplementations.set("message_notify_user", messageNotifyuser);
-    this.toolImplementations.set("ls_tool", ls);
-    this.toolImplementations.set("count_file_lines", countLines);
-    this.toolImplementations.set("read_file_lines", readLines);
-    this.toolImplementations.set("todo", todo);
-    this.toolImplementations.set("agent_end_turn", async () => ({ success: true, message: "Task ended by agent." }));
+}
+function calculateStats() {
+  const total = taskStore.length;
+  const pending = taskStore.filter((t) => t.status === "pending").length;
+  const inProgress = taskStore.filter((t) => t.status === "in_progress").length;
+  const completed = taskStore.filter((t) => t.status === "completed").length;
+  const progress = total > 0 ? Math.round(completed / total * 100) : 0;
+  return { total, pending, inProgress, completed, progress };
+}
+function validateDescription(desc) {
+  if (!desc || typeof desc !== "string") {
+    return "Description is required";
   }
-  /**
-   * Retorna a lista de definições de todas as ferramentas nativas carregadas.
-   * O MCPClient usará esta função para obter a lista de ferramentas locais.
-   */
-  getToolDefinitions() {
-    return this.toolDefinitions;
+  if (desc.trim().length === 0) {
+    return "Description cannot be empty";
   }
-  /**
-   * Invoca uma ferramenta nativa pelo nome com os argumentos fornecidos.
-   * @param toolName O nome da ferramenta a ser invocada.
-   * @param args Os argumentos para a ferramenta, geralmente um objeto.
-   * @returns O resultado da execução da ferramenta.
-   */
-  async invoke(toolName, args) {
-    const implementation = this.toolImplementations.get(toolName);
-    if (!implementation) {
-      return { error: `Error: Native tool "${toolName}" not found.` };
+  if (desc.length > 500) {
+    return "Description too long (max 500 chars)";
+  }
+  return null;
+}
+function createResult(success, message) {
+  return {
+    success,
+    message,
+    tasks: taskStore,
+    stats: calculateStats()
+  };
+}
+function listTasks() {
+  loadTasksFromFile();
+  const stats = calculateStats();
+  if (taskStore.length === 0) {
+    return createResult(true, "No tasks yet. Use add action to create tasks.");
+  }
+  const progressBar = generateProgressBar(stats.progress);
+  return createResult(true, `${stats.total} tasks ${progressBar} ${stats.progress}%`);
+}
+function addTasks(tasks) {
+  if (!tasks || tasks.length === 0) {
+    return createResult(false, "No tasks provided");
+  }
+  loadTasksFromFile();
+  for (const task of tasks) {
+    const error = validateDescription(task.description);
+    if (error) {
+      return createResult(false, `Invalid task: ${error}`);
     }
-    try {
-      return await implementation(args);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "An unknown error occurred.";
-      return { error: `Error executing tool "${toolName}": ${errorMessage}` };
+    const newTask = {
+      id: nextId++,
+      description: task.description.trim(),
+      status: task.isComplete ? "completed" : "pending",
+      priority: task.priority || "medium",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+    };
+    taskStore.push(newTask);
+  }
+  saveTasksToFile();
+  return createResult(true, `Added ${tasks.length} task(s)`);
+}
+function completeTask(taskId) {
+  loadTasksFromFile();
+  const task = taskStore.find((t) => t.id === taskId);
+  if (!task) {
+    return createResult(false, `Task #${taskId} not found`);
+  }
+  task.status = "completed";
+  task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveTasksToFile();
+  return createResult(true, `Completed: ${task.description}`);
+}
+function updateTask(taskId, description, priority) {
+  loadTasksFromFile();
+  const task = taskStore.find((t) => t.id === taskId);
+  if (!task) {
+    return createResult(false, `Task #${taskId} not found`);
+  }
+  if (description) {
+    const error = validateDescription(description);
+    if (error) {
+      return createResult(false, error);
     }
+    task.description = description.trim();
   }
-};
+  if (priority) {
+    task.priority = priority;
+  }
+  saveTasksToFile();
+  return createResult(true, `Updated task #${taskId}`);
+}
+function removeTask(taskId) {
+  loadTasksFromFile();
+  const index = taskStore.findIndex((t) => t.id === taskId);
+  if (index === -1) {
+    return createResult(false, `Task #${taskId} not found`);
+  }
+  const removed = taskStore.splice(index, 1)[0];
+  saveTasksToFile();
+  return createResult(true, `Removed: ${removed.description}`);
+}
+function clearCompleted() {
+  loadTasksFromFile();
+  const before = taskStore.length;
+  taskStore = taskStore.filter((t) => t.status !== "completed");
+  const removed = before - taskStore.length;
+  saveTasksToFile();
+  return createResult(true, `Cleared ${removed} completed task(s)`);
+}
+function generateProgressBar(percent) {
+  const width = 10;
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  return "[" + "=".repeat(filled) + " ".repeat(empty) + "]";
+}
+async function todo(args) {
+  if ("tasks" in args && !("action" in args)) {
+    loadTasksFromFile();
+    taskStore = [];
+    nextId = 1;
+    if (args.tasks && args.tasks.length > 0) {
+      for (const task of args.tasks) {
+        taskStore.push({
+          id: nextId++,
+          description: task.description,
+          status: task.isComplete ? "completed" : "pending",
+          priority: "medium",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+        });
+      }
+    }
+    saveTasksToFile();
+    const stats = calculateStats();
+    const progressBar = generateProgressBar(stats.progress);
+    return createResult(true, `Synced ${taskStore.length} tasks ${progressBar} ${stats.progress}%`);
+  }
+  const fullArgs = args;
+  switch (fullArgs.action) {
+    case "list":
+      return listTasks();
+    case "add":
+      return addTasks(fullArgs.tasks);
+    case "complete":
+      if (!fullArgs.taskId) {
+        return createResult(false, "taskId required for complete action");
+      }
+      return completeTask(fullArgs.taskId);
+    case "update":
+      if (!fullArgs.taskId) {
+        return createResult(false, "taskId required for update action");
+      }
+      return updateTask(fullArgs.taskId, fullArgs.description, fullArgs.priority);
+    case "remove":
+      if (!fullArgs.taskId) {
+        return createResult(false, "taskId required for remove action");
+      }
+      return removeTask(fullArgs.taskId);
+    case "clear":
+      return clearCompleted();
+    case "sync":
+      return addTasks(fullArgs.tasks);
+    default:
+      return createResult(false, `Unknown action: ${fullArgs.action}`);
+  }
+}
 
-// src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs7 } from "fs";
+// src/app/agent/tools/natives/find_by_name.ts
 import path6 from "path";
-import os3 from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-var MCPClient = class {
-  sessions = /* @__PURE__ */ new Map();
-  toolToServerMap = /* @__PURE__ */ new Map();
-  globalToolsForLlm = [];
-  nativeToolInvoker;
-  eventBus;
-  // <<< ADICIONA A PROPRIEDADE
-  constructor(nativeToolInvoker, eventBus2) {
-    this.nativeToolInvoker = nativeToolInvoker;
-    this.eventBus = eventBus2;
+import { promises as fsPromises } from "fs";
+var DEFAULT_IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".cache",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".nyc_output",
+  ".pytest_cache",
+  "target",
+  // Rust
+  "vendor"
+  // Go, PHP
+];
+var MAX_RESULTS2 = 100;
+var MAX_DEPTH_DEFAULT = 10;
+function globToRegex(glob) {
+  let regex = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLESTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/{{DOUBLESTAR}}/g, ".*");
+  return new RegExp(`^${regex}$`, "i");
+}
+function shouldIgnore(name, ignorePatterns, includeHidden) {
+  if (!includeHidden && name.startsWith(".")) {
+    return true;
   }
-  // ... (método initialize inalterado) ...
-  async initialize() {
-    const nativeTools = this.nativeToolInvoker.getToolDefinitions();
-    this.globalToolsForLlm.push(...nativeTools);
-    for (const tool of nativeTools) {
-      const toolName = tool.function.name;
-      this.toolToServerMap.set(toolName, {
-        server: "native",
-        originalName: toolName
-      });
+  for (const pattern of ignorePatterns) {
+    if (name === pattern || name.match(globToRegex(pattern))) {
+      return true;
     }
-    const __filename = fileURLToPath2(import.meta.url);
-    const __dirname = path6.dirname(__filename);
-    const defaultConfigPath = path6.resolve(__dirname, "config", "bluma-mcp.json");
-    const userConfigPath = path6.join(os3.homedir(), ".bluma-cli", "bluma-mcp.json");
-    const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
-    const userConfig = await this.loadMcpConfig(userConfigPath, "User");
-    const mergedConfig = {
-      mcpServers: {
-        ...defaultConfig.mcpServers || {},
-        ...userConfig.mcpServers || {}
-      }
-    };
-    if (Object.keys(mergedConfig.mcpServers).length === 0) {
-      return;
+  }
+  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 serverEntries = Object.entries(mergedConfig.mcpServers);
-    for (const [serverName, serverConf] of serverEntries) {
-      try {
-        this.eventBus.emit("backend_message", {
-          type: "connection_status",
-          message: `${serverName} server is being connected...`
+    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"
         });
-        if (serverConf.type === "stdio") {
-          await this.connectToStdioServer(serverName, serverConf);
-        } else if (serverConf.type === "sse") {
-          console.warn(`[MCPClient] Conex\xE3o com servidores SSE (como '${serverName}') ainda n\xE3o implementada.`);
+      }
+      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"
+          });
         }
-      } catch (error) {
-        this.eventBus.emit("backend_message", {
-          type: "error",
-          message: `Failed to connect to server '${serverName}'.`
-        });
       }
     }
   }
-  async loadMcpConfig(configPath, configType) {
+}
+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 fileContent = await fs7.readFile(configPath, "utf-8");
-      const processedContent = this.replaceEnvPlaceholders(fileContent);
+      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";
+  }
+  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 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;
+    }
+    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;
+      }
+    }
+  }
+  return items;
+}
+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 { 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 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}`
+    };
+  }
+}
+
+// src/app/agent/tools/natives/async_command.ts
+import os3 from "os";
+import { spawn as spawn2 } from "child_process";
+import { v4 as uuidv42 } from "uuid";
+var runningCommands = /* @__PURE__ */ new Map();
+var MAX_OUTPUT_SIZE2 = 1e5;
+var MAX_STORED_COMMANDS = 50;
+var OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED]";
+var DANGEROUS_PATTERNS2 = [
+  /^sudo\s+/i,
+  /^doas\s+/i,
+  /^su\s+/i,
+  /\|\s*sudo\s+/i
+];
+var INTERACTIVE_PATTERNS2 = [
+  /^(vim|vi|nano|emacs|less|more)\s*/i,
+  /^(top|htop|btop)\s*/i,
+  /^(mysql|psql|redis-cli|mongo)\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 isDangerousCommand(command) {
+  const trimmed = command.trim();
+  for (const pattern of DANGEROUS_PATTERNS2) {
+    if (pattern.test(trimmed)) {
+      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
+    }
+  }
+  for (const pattern of INTERACTIVE_PATTERNS2) {
+    if (pattern.test(trimmed)) {
+      return "Interactive commands are not supported in async mode";
+    }
+  }
+  return null;
+}
+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"
+      };
+    }
+    const dangerReason = isDangerousCommand(command);
+    if (dangerReason) {
+      return {
+        success: false,
+        error: dangerReason
+      };
+    }
+    const commandId = uuidv42().substring(0, 8);
+    const platform = os3.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 = spawn2(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_SIZE2) {
+          entry.stdout = entry.stdout.substring(0, MAX_OUTPUT_SIZE2) + 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_SIZE2) {
+          entry.stderr = entry.stderr.substring(0, MAX_OUTPUT_SIZE2) + 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);
+    }
+    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"
+      };
+    }
+    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.`
+      };
+    }
+    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);
+      });
+    }
+    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;
+    }
+    if (stderr.length > output_limit) {
+      stderr = "..." + stderr.substring(stderr.length - output_limit);
+      truncated = true;
+    }
+    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"
+      };
+    }
+    const entry = runningCommands.get(command_id);
+    if (!entry) {
+      return {
+        success: false,
+        error: `Command with id "${command_id}" not found`
+      };
+    }
+    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}`
+    };
+  }
+}
+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`
+      };
+    }
+    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`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to kill command: ${error.message}`
+    };
+  }
+}
+
+// src/app/agent/tools/natives/task_boundary.ts
+import path9 from "path";
+import { promises as fs7 } from "fs";
+import os4 from "os";
+var currentTask = null;
+var artifactsDir = null;
+async function getArtifactsDir() {
+  if (artifactsDir) return artifactsDir;
+  const homeDir = os4.homedir();
+  const baseDir = path9.join(homeDir, ".bluma", "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 });
+  return artifactsDir;
+}
+async function updateTaskFile(task) {
+  const dir = await getArtifactsDir();
+  const taskFile = path9.join(dir, "task.md");
+  const content = `# ${task.taskName}
+
+**Mode:** ${task.mode}  
+**Status:** ${task.status}  
+**Started:** ${new Date(task.startTime).toISOString()}  
+**Updated:** ${new Date(task.updateTime).toISOString()}  
+**Steps:** ${task.stepCount}
+
+## Summary
+${task.summary}
+`;
+  await fs7.writeFile(taskFile, content, "utf-8");
+}
+async function taskBoundary(args) {
+  try {
+    const { task_name, mode, task_status, task_summary } = args;
+    if (!task_name || typeof task_name !== "string") {
+      return {
+        success: false,
+        task_name: "",
+        mode: "EXECUTION",
+        status: "",
+        message: "task_name is required"
+      };
+    }
+    if (!["PLANNING", "EXECUTION", "VERIFICATION"].includes(mode)) {
+      return {
+        success: false,
+        task_name,
+        mode: "EXECUTION",
+        status: "",
+        message: `Invalid mode: ${mode}. Must be PLANNING, EXECUTION, or VERIFICATION`
+      };
+    }
+    if (!task_status || typeof task_status !== "string") {
+      return {
+        success: false,
+        task_name,
+        mode,
+        status: "",
+        message: "task_status is required"
+      };
+    }
+    const now = Date.now();
+    if (currentTask && currentTask.taskName === task_name) {
+      currentTask.mode = mode;
+      currentTask.status = task_status;
+      currentTask.summary = task_summary || currentTask.summary;
+      currentTask.updateTime = now;
+      currentTask.stepCount++;
+    } else {
+      currentTask = {
+        taskName: task_name,
+        mode,
+        status: task_status,
+        summary: task_summary || "",
+        startTime: now,
+        updateTime: now,
+        stepCount: 1
+      };
+    }
+    await updateTaskFile(currentTask);
+    const dir = await getArtifactsDir();
+    return {
+      success: true,
+      task_name: currentTask.taskName,
+      mode: currentTask.mode,
+      status: currentTask.status,
+      message: `Task "${task_name}" is now in ${mode} mode. Status: ${task_status}`,
+      artifacts_dir: dir
+    };
+  } catch (error) {
+    return {
+      success: false,
+      task_name: args.task_name || "",
+      mode: args.mode || "EXECUTION",
+      status: args.task_status || "",
+      message: `Error: ${error.message}`
+    };
+  }
+}
+
+// src/app/agent/tools/natives/search_web.ts
+import https from "https";
+import http from "http";
+var DEFAULT_SOURCES = ["reddit", "github", "stackoverflow"];
+var MAX_RESULTS_DEFAULT = 10;
+var REQUEST_TIMEOUT = 1e4;
+function httpGet(url, customHeaders) {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith("https") ? https : http;
+    const defaultHeaders = {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      "Accept": "application/json, text/html, */*",
+      "Accept-Language": "en-US,en;q=0.9",
+      "Accept-Encoding": "identity",
+      // Não usar gzip para simplificar
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      ...customHeaders
+    };
+    const req = protocol.get(url, {
+      headers: defaultHeaders,
+      timeout: REQUEST_TIMEOUT
+    }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        httpGet(res.headers.location, customHeaders).then(resolve).catch(reject);
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          resolve(data);
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 200)}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+  });
+}
+async function searchReddit(query, limit) {
+  const results = [];
+  try {
+    const subreddits = "programming+webdev+javascript+typescript+python+node+reactjs+learnprogramming";
+    const encodedQuery = encodeURIComponent(query);
+    const url = `https://www.reddit.com/r/${subreddits}/search.json?q=${encodedQuery}&sort=relevance&limit=${limit}&restrict_sr=on`;
+    const response = await httpGet(url);
+    const data = JSON.parse(response);
+    if (data.data?.children) {
+      for (const child of data.data.children.slice(0, limit)) {
+        const post = child.data;
+        results.push({
+          title: post.title || "",
+          url: `https://reddit.com${post.permalink}`,
+          source: "reddit",
+          snippet: post.selftext?.substring(0, 200) || `r/${post.subreddit} - ${post.score} upvotes`,
+          score: post.score
+        });
+      }
+    }
+  } catch (error) {
+    console.error(`[search_web] Reddit error: ${error.message}`);
+  }
+  return results;
+}
+async function searchGitHub(query, limit) {
+  const results = [];
+  try {
+    const encodedQuery = encodeURIComponent(query);
+    const url = `https://api.github.com/search/issues?q=${encodedQuery}+is:issue&sort=reactions&order=desc&per_page=${limit}`;
+    const response = await httpGet(url);
+    const data = JSON.parse(response);
+    if (data.items) {
+      for (const item of data.items.slice(0, limit)) {
+        results.push({
+          title: item.title || "",
+          url: item.html_url || "",
+          source: "github",
+          snippet: item.body?.substring(0, 200) || `${item.comments} comments`,
+          score: item.reactions?.total_count || 0
+        });
+      }
+    }
+  } catch (error) {
+    console.error(`[search_web] GitHub error: ${error.message}`);
+  }
+  return results;
+}
+async function searchStackOverflow(query, limit) {
+  const results = [];
+  try {
+    const encodedQuery = encodeURIComponent(query);
+    const url = `https://api.stackexchange.com/2.3/search?order=desc&sort=relevance&intitle=${encodedQuery}&site=stackoverflow&pagesize=${limit}`;
+    const response = await httpGet(url);
+    const data = JSON.parse(response);
+    if (data.items) {
+      for (const item of data.items.slice(0, limit)) {
+        results.push({
+          title: item.title || "",
+          url: item.link || "",
+          source: "stackoverflow",
+          snippet: `${item.score} votes, ${item.answer_count} answers${item.is_answered ? " \u2713" : ""}`,
+          score: item.score
+        });
+      }
+    }
+  } catch (error) {
+    console.error(`[search_web] StackOverflow error: ${error.message}`);
+  }
+  return results;
+}
+function getXSearchUrl(query) {
+  const encodedQuery = encodeURIComponent(query);
+  return {
+    title: `Search X for: "${query}"`,
+    url: `https://twitter.com/search?q=${encodedQuery}&src=typed_query&f=live`,
+    source: "x",
+    snippet: "X/Twitter requires authentication. Click the link to search manually."
+  };
+}
+async function searchWeb(args) {
+  try {
+    const {
+      query,
+      sources = DEFAULT_SOURCES,
+      max_results = MAX_RESULTS_DEFAULT
+    } = args;
+    if (!query || typeof query !== "string") {
+      return {
+        success: false,
+        query: query || "",
+        results: [],
+        sources_searched: [],
+        total_results: 0,
+        error: "query is required and must be a string"
+      };
+    }
+    const allResults = [];
+    const sourcesSearched = [];
+    const resultsPerSource = Math.ceil(max_results / sources.length);
+    const searches = [];
+    for (const source of sources) {
+      sourcesSearched.push(source);
+      switch (source) {
+        case "reddit":
+          searches.push(searchReddit(query, resultsPerSource));
+          break;
+        case "github":
+          searches.push(searchGitHub(query, resultsPerSource));
+          break;
+        case "stackoverflow":
+          searches.push(searchStackOverflow(query, resultsPerSource));
+          break;
+        case "x":
+          allResults.push(getXSearchUrl(query));
+          break;
+      }
+    }
+    const searchResults = await Promise.all(searches);
+    for (const results of searchResults) {
+      allResults.push(...results);
+    }
+    allResults.sort((a, b) => (b.score || 0) - (a.score || 0));
+    const limitedResults = allResults.slice(0, max_results);
+    return {
+      success: true,
+      query,
+      results: limitedResults,
+      sources_searched: sourcesSearched,
+      total_results: limitedResults.length,
+      note: sources.includes("x") ? "X/Twitter requires manual search due to API restrictions" : void 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      query: args.query || "",
+      results: [],
+      sources_searched: [],
+      total_results: 0,
+      error: `Unexpected error: ${error.message}`
+    };
+  }
+}
+
+// src/app/agent/tool_invoker.ts
+var ToolInvoker = class {
+  // Mapa privado para associar nomes de ferramentas às suas funções de implementação.
+  toolImplementations;
+  // Propriedade privada para armazenar as definições de ferramentas carregadas do JSON.
+  toolDefinitions = [];
+  constructor() {
+    this.toolImplementations = /* @__PURE__ */ new Map();
+    this.registerTools();
+  }
+  /**
+   * Carrega as definições de ferramentas do arquivo de configuração `native_tools.json`.
+   * Este método é assíncrono e deve ser chamado após a criação da instância.
+   */
+  async initialize() {
+    try {
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = path10.dirname(__filename);
+      const configPath = path10.resolve(__dirname, "config", "native_tools.json");
+      const fileContent = await fs8.readFile(configPath, "utf-8");
+      const config2 = JSON.parse(fileContent);
+      this.toolDefinitions = config2.nativeTools;
+    } catch (error) {
+      console.error("[ToolInvoker] Erro cr\xEDtico ao carregar 'native_tools.json'. As ferramentas nativas n\xE3o estar\xE3o dispon\xEDveis.", error);
+      this.toolDefinitions = [];
+    }
+  }
+  /**
+   * Registra as implementações de todas as ferramentas nativas.
+   * Este método mapeia o nome da ferramenta (string) para a função TypeScript que a executa.
+   */
+  registerTools() {
+    this.toolImplementations.set("shell_command", shellCommand);
+    this.toolImplementations.set("edit_tool", editTool);
+    this.toolImplementations.set("ls_tool", ls);
+    this.toolImplementations.set("count_file_lines", countLines);
+    this.toolImplementations.set("read_file_lines", readLines);
+    this.toolImplementations.set("find_by_name", findByName);
+    this.toolImplementations.set("grep_search", grepSearch);
+    this.toolImplementations.set("view_file_outline", viewFileOutline);
+    this.toolImplementations.set("run_command_async", runCommandAsync);
+    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("todo", todo);
+    this.toolImplementations.set("task_boundary", taskBoundary);
+    this.toolImplementations.set("search_web", searchWeb);
+    this.toolImplementations.set("agent_end_turn", async () => ({ success: true, message: "Task ended by agent." }));
+  }
+  /**
+   * Retorna a lista de definições de todas as ferramentas nativas carregadas.
+   * O MCPClient usará esta função para obter a lista de ferramentas locais.
+   */
+  getToolDefinitions() {
+    return this.toolDefinitions;
+  }
+  /**
+   * Invoca uma ferramenta nativa pelo nome com os argumentos fornecidos.
+   * @param toolName O nome da ferramenta a ser invocada.
+   * @param args Os argumentos para a ferramenta, geralmente um objeto.
+   * @returns O resultado da execução da ferramenta.
+   */
+  async invoke(toolName, args) {
+    const implementation = this.toolImplementations.get(toolName);
+    if (!implementation) {
+      return { error: `Error: Native tool "${toolName}" not found.` };
+    }
+    try {
+      return await implementation(args);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "An unknown error occurred.";
+      return { error: `Error executing tool "${toolName}": ${errorMessage}` };
+    }
+  }
+};
+
+// src/app/agent/tools/mcp/mcp_client.ts
+import { promises as fs9 } from "fs";
+import path11 from "path";
+import os5 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var MCPClient = class {
+  sessions = /* @__PURE__ */ new Map();
+  toolToServerMap = /* @__PURE__ */ new Map();
+  globalToolsForLlm = [];
+  nativeToolInvoker;
+  eventBus;
+  // <<< ADICIONA A PROPRIEDADE
+  constructor(nativeToolInvoker, eventBus2) {
+    this.nativeToolInvoker = nativeToolInvoker;
+    this.eventBus = eventBus2;
+  }
+  // ... (método initialize inalterado) ...
+  async initialize() {
+    const nativeTools = this.nativeToolInvoker.getToolDefinitions();
+    this.globalToolsForLlm.push(...nativeTools);
+    for (const tool of nativeTools) {
+      const toolName = tool.function.name;
+      this.toolToServerMap.set(toolName, {
+        server: "native",
+        originalName: toolName
+      });
+    }
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = path11.dirname(__filename);
+    const defaultConfigPath = path11.resolve(__dirname, "config", "bluma-mcp.json");
+    const userConfigPath = path11.join(os5.homedir(), ".bluma-cli", "bluma-mcp.json");
+    const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
+    const userConfig = await this.loadMcpConfig(userConfigPath, "User");
+    const mergedConfig = {
+      mcpServers: {
+        ...defaultConfig.mcpServers || {},
+        ...userConfig.mcpServers || {}
+      }
+    };
+    if (Object.keys(mergedConfig.mcpServers).length === 0) {
+      return;
+    }
+    const serverEntries = Object.entries(mergedConfig.mcpServers);
+    for (const [serverName, serverConf] of serverEntries) {
+      try {
+        this.eventBus.emit("backend_message", {
+          type: "connection_status",
+          message: `${serverName} server is being connected...`
+        });
+        if (serverConf.type === "stdio") {
+          await this.connectToStdioServer(serverName, serverConf);
+        } else if (serverConf.type === "sse") {
+          console.warn(`[MCPClient] Conex\xE3o com servidores SSE (como '${serverName}') ainda n\xE3o implementada.`);
+        }
+      } catch (error) {
+        this.eventBus.emit("backend_message", {
+          type: "error",
+          message: `Failed to connect to server '${serverName}'.`
+        });
+      }
+    }
+  }
+  async loadMcpConfig(configPath, configType) {
+    try {
+      const fileContent = await fs9.readFile(configPath, "utf-8");
+      const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -2035,7 +3696,7 @@ var MCPClient = class {
   async connectToStdioServer(serverName, config2) {
     let commandToExecute = config2.command;
     let argsToExecute = config2.args || [];
-    const isWindows = os3.platform() === "win32";
+    const isWindows = os5.platform() === "win32";
     if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
       if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
         commandToExecute = argsToExecute[1];
@@ -2151,12 +3812,12 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path9 from "path";
+import path14 from "path";
 
-// src/app/agent/session_manger/session_manager.ts
-import path7 from "path";
-import os4 from "os";
-import { promises as fs8 } from "fs";
+// src/app/agent/session_manager/session_manager.ts
+import path12 from "path";
+import os6 from "os";
+import { promises as fs10 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -2174,13 +3835,13 @@ async function withFileLock(file, fn) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path7.join(os4.homedir(), p.slice(1));
+    return path12.join(os6.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path7.join(os4.homedir(), ".bluma-cli");
-  return path7.resolve(expandHome(fixed));
+  const fixed = path12.join(os6.homedir(), ".bluma-cli");
+  return path12.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -2188,7 +3849,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      await fs8.rename(src, dest);
+      await fs10.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -2201,9 +3862,9 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    const data = await fs8.readFile(src);
-    await fs8.writeFile(dest, data);
-    await fs8.unlink(src).catch(() => {
+    const data = await fs10.readFile(src);
+    await fs10.writeFile(dest, data);
+    await fs10.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -2212,16 +3873,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path7.join(appDir, "sessions");
-  await fs8.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path12.join(appDir, "sessions");
+  await fs10.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadOrcreateSession(sessionId2) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path7.join(sessionDir, `${sessionId2}.json`);
+  const sessionFile = path12.join(sessionDir, `${sessionId2}.json`);
   try {
-    await fs8.access(sessionFile);
-    const fileContent = await fs8.readFile(sessionFile, "utf-8");
+    await fs10.access(sessionFile);
+    const fileContent = await fs10.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     return [sessionFile, [], []];
   } catch (error) {
@@ -2230,7 +3891,7 @@ async function loadOrcreateSession(sessionId2) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
-    await fs8.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    await fs10.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     return [sessionFile, [], []];
   }
 }
@@ -2238,12 +3899,12 @@ async function saveSessionHistory(sessionFile, history) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path7.dirname(sessionFile);
-      await fs8.mkdir(dir, { recursive: true });
+      const dir = path12.dirname(sessionFile);
+      await fs10.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs8.readFile(sessionFile, "utf-8");
+      const fileContent = await fs10.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -2254,14 +3915,14 @@ async function saveSessionHistory(sessionFile, history) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId2 = path7.basename(sessionFile, ".json");
+      const sessionId2 = path12.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId2,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs8.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs10.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -2269,7 +3930,7 @@ async function saveSessionHistory(sessionFile, history) {
     sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs8.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs10.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -2278,7 +3939,7 @@ async function saveSessionHistory(sessionFile, history) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs8.unlink(tempSessionFile);
+        await fs10.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -2286,181 +3947,327 @@ async function saveSessionHistory(sessionFile, history) {
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
-import os5 from "os";
-import fs9 from "fs";
-import path8 from "path";
+import os7 from "os";
+import fs11 from "fs";
+import path13 from "path";
+import { execSync } from "child_process";
+function getNodeVersion() {
+  try {
+    return process.version;
+  } catch {
+    return "unknown";
+  }
+}
+function getNpmVersion() {
+  try {
+    return execSync("npm --version", { encoding: "utf-8", timeout: 5e3 }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function getGitBranch(dir) {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd: dir,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return "N/A";
+  }
+}
+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";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function getProjectType(dir) {
+  try {
+    const files = fs11.readdirSync(dir);
+    if (files.includes("package.json")) {
+      const pkg = JSON.parse(fs11.readFileSync(path13.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";
+      if (pkg.dependencies?.vue || pkg.devDependencies?.vue) return "Vue";
+      if (pkg.dependencies?.angular || pkg.devDependencies?.angular) return "Angular";
+      return "Node.js";
+    }
+    if (files.includes("requirements.txt") || files.includes("pyproject.toml")) return "Python";
+    if (files.includes("Cargo.toml")) return "Rust";
+    if (files.includes("go.mod")) return "Go";
+    if (files.includes("pom.xml") || files.includes("build.gradle")) return "Java";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+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 deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.jest) return "jest";
+      if (deps.vitest) return "vitest";
+      if (deps.mocha) return "mocha";
+      if (deps.ava) return "ava";
+      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";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function getTestCommand(dir) {
+  try {
+    const pkgPath = path13.join(dir, "package.json");
+    if (fs11.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+      if (pkg.scripts?.test) return `npm test`;
+      if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
+    }
+    const pm = getPackageManager(dir);
+    const tf = getTestFramework(dir);
+    if (tf === "pytest") return "pytest";
+    if (tf === "jest") return `${pm} test`;
+    if (tf === "vitest") return `${pm} run test`;
+    return "npm test";
+  } catch {
+    return "npm test";
+  }
+}
 var SYSTEM_PROMPT = `
 <identity>
-You are BluMa, an autonomous coding agent by NomadEngenuity.
-You are a senior peer engineer working closely with {username} - technical, direct, and collaborative.
-- Always respond in the same language used by the user in their message.
-- Think and act like a senior teammate who can suggest improvements, spot issues, and mentor where needed.
+You are BluMa, an autonomous coding agent developed by NomadEngenuity.
+You are a **senior peer engineer** working alongside {username} - technical, proactive, and collaborative.
+You know this machine better than anyone. You understand the project structure, dependencies, and conventions.
+You are not just an assistant - you are a **teammate** who takes ownership of tasks.
+
+Key traits:
+- Think like a senior developer who has been on this project for years
+- Suggest improvements proactively, don't just follow orders blindly
+- Spot bugs and issues before they become problems
+- Write tests as naturally as you write code
+- Always communicate your reasoning and progress
 </identity>
 
 ---
 
-<message_rules>
-  <philosophy>
-    You are a collaborator, not a silent executor. Communication is your CORE responsibility.
-    The human partner must ALWAYS know:
-    - What you are reasoning
-    - What you are doing
-    - What tools you are using
-    - What difficulties you encounter
-  </philosophy>
-
-  <golden_rule>
-    <description>Immediate response is the start of your turn.</description>
-    <steps>
-      <step>1. Upon receiving ANY user message, ACKNOWLEDGE FIRST via message_notify_user.</step>
-      <step>2. State your next action clearly before doing anything else.</step>
-    </steps>
-  </golden_rule>
-
-  <mandatory_reporting>
-    <description>You MUST report EVERY step and EVERY tool usage to the user via message_notify_user.</description>
-    <rules>
-      <rule>Before using ANY tool, send a message explaining WHY and WHAT you will do.</rule>
-      <rule>After using ANY tool, send a message summarizing the result and next step.</rule>
-      <rule>NEVER perform silent actions. Every decision and execution MUST be communicated.</rule>
-    </rules>
-  </mandatory_reporting>
-
-  <acknowledgement_rule>
-    For messages with \`name\` (including \`user_overlay\`):
-    <rule>Confirm receipt via message_notify_user.</rule>
-    <rule>State the immediate step you will take.</rule>
-  </acknowledgement_rule>
-
-  <strict_constraints>
-    <constraint>The message_notify_user tool is your ONLY channel for communication with the human user.</constraint>
-    <constraint>NEVER assume the user knows what you are doing behind the scenes.</constraint>
-    <constraint>ALWAYS verbalize your reasoning, actions, and intentions before and after execution.</constraint>
-  </strict_constraints>
-
-  <example>
-    <![CDATA[
-    message_notify_user("Acknowledged. I will now create a TODO plan for the requested feature.")
-    message_notify_user("TODO plan created. Next, I will start implementing the authentication module.")
-    message_notify_user("Authentication module implemented. Running tests now.")
-    ]]>
-  </example>
-</message_rules>
+<environment>
+## Machine Context (Your Deep Knowledge)
+
+**System:**
+- OS: {os_type} ({os_version})
+- Architecture: {architecture}
+- Shell: {shell_type}
+- Node.js: {node_version}
+- NPM: {npm_version}
+- User: {username}
+
+**Project:**
+- Working Directory: {workdir}
+- Project Type: {project_type}
+- Package Manager: {package_manager}
+- Test Framework: {test_framework}
+- Test Command: {test_command}
+
+**Git:**
+- Is Git Repo: {is_git_repo}
+- Current Branch: {git_branch}
+
+**Session:**
+- Date: {current_date}
+- Timezone: {timezone}
+
+You MUST adapt all commands to this environment. Use the correct package manager, test framework, and conventions.
+</environment>
+
+---
+
+<workflow>
+## How You Work
 
----
+### For Multi-Step Tasks:
+1. **Acknowledge** - Confirm the request immediately via message_notify_user
+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)
+5. **Verify** - Check build, lint, and git status
+6. **Summarize** - Report results and any follow-up actions
 
+### For Simple Tasks:
+- Quick acknowledgment + immediate action
+- No TODO needed for single operations
 
-<communication_style>
+### Testing Philosophy (CRITICAL):
+You are a **teammate who writes tests**, not an assistant who skips them.
 
-The user identity must always be converted from {username} into a natural human name.
+**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
 
-Conversion rule:
-- Replace "-" "_" "." with spaces
-- Capitalize each word
-- Remove numbers or suffixes that are not part of natural names
+**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
 
-Examples:
-  {username}: jhon-doe \u2192 "Jhon Doe"
-  {username}: joao_pereira_22 \u2192 "Joao Pereira"
+**Commands you should know:**
+- Run tests: {test_command}
+- Run single test: Check project conventions
+- Watch mode: Usually \`npm run test:watch\` or \`npm test -- --watch\`
+</workflow>
 
-Use the converted name in all natural conversation.
-Never address the user using the raw {username} handle.
+---
 
-You're a teammate on Slack/Discord, not a formal assistant.
-Be natural, direct, and technical.
+<tool_rules>
+## Tool Calling Best Practices
 
-When interacting:
-- Start messages using the converted human name.
-- Skip formalities; get straight to the point.
-- Narrate your reasoning when needed.
+### File Operations:
+- **ALWAYS read a file before editing** - Use read_file_lines or ls_tool first
+- **Use absolute paths** when possible to avoid ambiguity
+- **For edit_tool**: Provide exact content with correct whitespace (read first!)
+- **Check file exists** before attempting edits
 
-Example conversations to follow:
+### Shell Commands:
+- **NEVER use sudo** - Commands requiring sudo will be blocked
+- **Long commands**: Set appropriate timeout (default 300s)
+- **Interactive commands** (vim, less, ssh) are blocked - use alternatives
+- **Large outputs** will be truncated at 100KB
 
-[Example 1]
-Jhon Doe: The /auth/login endpoint is slow.
-Teammate: Jhon Doe, checking it now. bcrypt cost is set to 14. Dropping it to 10.
+### Safe Auto-Approved Tools (no confirmation needed):
+- message_notify_user
+- ls_tool
+- read_file_lines
+- count_file_lines
+- todo
+- agent_end_turn
 
-[Example 2]
-Jhon Doe: Pushed the payments module. Review when you can.
-Teammate: Looking at it. Just narrow the try/catch to a specific Stripe error.
+### Require Confirmation:
+- shell_command (except safe commands)
+- edit_tool (always shows diff preview)
+</tool_rules>
 
-[Example 3]
-Jhon Doe: Redis or Postgres for sessions?
-Teammate: Jhon Doe, Redis. Low latency, ephemeral data.
+---
 
-[Example 4]
-Jhon Doe: Merge conflict between dev and feature/auth.
-Teammate: Rebase your feature on top of dev. Resolve conflicts and force push.
+<communication_style>
+## How You Communicate
 
-[Example 5]
-Jhon Doe: Tests pass locally but fail in CI.
-Teammate: CI is running Node 18. You're on Node 20. I'll update the .nvmrc.
+Convert {username} to a natural name:
+- Replace "-" "_" "." with spaces
+- Capitalize each word  
+- Remove trailing numbers
 
-</communication_style>
+Examples:
+- alex-fonseca \u2192 "Alex Fonseca"
+- joao_pereira_22 \u2192 "Joao Pereira"
 
+**Style:**
+- Direct and technical, like Slack/Discord
+- Get straight to the point
+- Narrate your reasoning
+- Celebrate wins, acknowledge mistakes
 
-<workflow>
-For multi-step tasks:
-1. Use TODO to plan (one task list per request)
-2. Share reasoning before coding
-3. Execute with narration
-4. Test when relevant
-5. Summarize results
-
-For simple tasks:
-- Quick ack + immediate action
-- No TODO needed for single operations
-</workflow>
+**Message via tool only:**
+- Use message_notify_user for ALL communication
+- Never assume the user sees internal state
+- Report progress proactively
 
-<technical_standards>
-When writing code:
-- Production-ready, testable solutions
-- Follow best practices for the stack
-- Include error handling
-- Write tests for core logic (80%+ coverage)
+**Example flow:**
+\`\`\`
+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.")
+\`\`\`
+</communication_style>
 
-Before finishing:
-- Run tests if applicable
-- Verify build passes
-- Check git status if in repo
-</technical_standards>
+---
 
 <git_guidelines>
+## Git Best Practices
+
 When in a git repository:
-- Review changes: git diff HEAD
-- Commit with conventional format: "feat: add X" / "fix: resolve Y"
-- NEVER push unless explicitly asked
-- NEVER use destructive commands (reset --hard, rebase)
+- **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
+
+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>
 
-<environment>
-Current session context:
-- OS: {os_type} ({os_version})
-- Architecture: {architecture}
-- Directory: {workdir}
-- Shell: {shell_type}
-- User: {username}
-- Date: {current_date}
-- Timezone: {timezone}
-- Git repo: {is_git_repo}
+---
 
-Adapt your commands to this environment.
-</environment>
+<code_quality>
+## Your Code Standards
+
+**Every piece of code you write should be:**
+- Production-ready and properly typed
+- Self-documenting with clear names
+- Properly error-handled
+- Tested (unit tests for logic, integration for APIs)
+
+**Before finishing ANY task:**
+1. Run tests: {test_command}
+2. Check for lint errors if linter exists
+3. Verify build passes if applicable
+4. Review git status if in repo
+
+**Code review mindset:**
+- Would this pass code review from a senior dev?
+- Are there edge cases I haven't considered?
+- Is the error handling robust?
+- Are there security implications?
+</code_quality>
 
+---
+
+<personality>
 You are BluMa. Autonomous, precise, collaborative.
+You don't just execute - you think, suggest, and improve.
+You test your code because you care about quality.
+You communicate because you respect your teammate.
+
 Let's build something great, {username}.
+</personality>
 `;
 function getUnifiedSystemPrompt() {
+  const cwd = process.cwd();
   const env = {
-    os_type: os5.type(),
-    os_version: os5.release(),
-    architecture: os5.arch(),
-    workdir: process.cwd(),
+    os_type: os7.type(),
+    os_version: os7.release(),
+    architecture: os7.arch(),
+    workdir: cwd,
     shell_type: process.env.SHELL || process.env.COMSPEC || "unknown",
-    username: os5.userInfo().username,
+    username: os7.userInfo().username,
     current_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    is_git_repo: isGitRepo(process.cwd()) ? "yes" : "no"
+    is_git_repo: isGitRepo(cwd) ? "yes" : "no",
+    node_version: getNodeVersion(),
+    npm_version: getNpmVersion(),
+    git_branch: getGitBranch(cwd),
+    package_manager: getPackageManager(cwd),
+    project_type: getProjectType(cwd),
+    test_framework: getTestFramework(cwd),
+    test_command: getTestCommand(cwd)
   };
   return Object.entries(env).reduce(
     (prompt, [key, value]) => prompt.replaceAll(`{${key}}`, value),
@@ -2469,8 +4276,8 @@ function getUnifiedSystemPrompt() {
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path8.join(dir, ".git");
-    return fs9.existsSync(gitPath) && fs9.lstatSync(gitPath).isDirectory();
+    const gitPath = path13.join(dir, ".git");
+    return fs11.existsSync(gitPath) && fs11.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -2712,7 +4519,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path9.basename(toolArgs.file_path);
+      const filename = path14.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}`;
@@ -2740,6 +4547,13 @@ ${editData.error.display}`;
       }
       let message = response.choices[0].message;
       message = ToolCallNormalizer.normalizeAssistantMessage(message);
+      if (message.reasoning_content || message.reasoning) {
+        const reasoningText = message.reasoning_content || message.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(
@@ -2756,7 +4570,6 @@ ${editData.error.display}`;
         const autoApprovedTools = [
           "agent_end_turn",
           "message_notify_user",
-          "reasoning_nootebook",
           "ls_tool",
           "count_file_lines",
           "read_file_lines",
@@ -2830,7 +4643,7 @@ function getSubAgentByCommand(cmd) {
 }
 
 // src/app/agent/subagents/init/init_system_prompt.ts
-import os6 from "os";
+import os8 from "os";
 var SYSTEM_PROMPT2 = `
 
 ### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -2993,12 +4806,12 @@ Rule Summary:
 function getInitPrompt() {
   const now = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os6.type(),
-    os_version: os6.release(),
-    architecture: os6.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: os6.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",
@@ -3251,7 +5064,7 @@ var SubAgentsBluMa = class {
 };
 
 // src/app/agent/agent.ts
-var globalEnvPath = path10.join(os7.homedir(), ".bluma-cli", ".env");
+var globalEnvPath = path15.join(os9.homedir(), ".bluma-cli", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -3386,10 +5199,10 @@ var Agent = class {
 };
 
 // src/app/ui/WorkingTimer.tsx
-import { useState as useState4, useEffect as useEffect4 } from "react";
+import { useState as useState4, useEffect as useEffect4, memo as memo5 } from "react";
 import { Box as Box7, Text as Text7 } from "ink";
 import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
-var WorkingTimer = () => {
+var WorkingTimerComponent = ({ taskName, taskStatus }) => {
   const [seconds, setSeconds] = useState4(0);
   const [frame, setFrame] = useState4(0);
   useEffect4(() => {
@@ -3400,210 +5213,309 @@ var WorkingTimer = () => {
   }, []);
   useEffect4(() => {
     const animator = setInterval(() => {
-      setFrame((prev) => (prev + 1) % 10);
-    }, 80);
+      setFrame((prev) => (prev + 1) % 4);
+    }, 150);
     return () => clearInterval(animator);
   }, []);
-  const spinners = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  const spinners = ["|", "/", "-", "\\"];
   const spinner = spinners[frame];
-  return /* @__PURE__ */ jsxs7(Box7, { paddingX: 1, marginBottom: 0, children: [
-    /* @__PURE__ */ jsx7(Text7, { color: "magenta", children: spinner }),
-    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " thinking" }),
-    /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
-      " ",
-      seconds,
-      "s"
-    ] })
+  const formatTime = (s) => {
+    if (s < 60) return `${s}s`;
+    return `${Math.floor(s / 60)}m${s % 60}s`;
+  };
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: spinner }),
+      /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+        " ",
+        taskStatus || "thinking"
+      ] }),
+      /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+        " ",
+        formatTime(seconds)
+      ] })
+    ] }),
+    taskName && /* @__PURE__ */ jsx7(Box7, { paddingLeft: 2, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "^ ",
+      taskName
+    ] }) })
   ] });
 };
+var WorkingTimer = memo5(WorkingTimerComponent);
 
 // src/app/ui/components/ToolCallDisplay.tsx
-import { memo as memo3 } from "react";
+import { memo as memo6 } from "react";
 import { Box as Box9 } from "ink";
 
 // src/app/ui/components/toolCallRenderers.tsx
 import { Box as Box8, Text as Text8 } from "ink";
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
-var formatArgumentsForDisplay = (args) => {
+var parseArgs = (args) => {
   if (typeof args === "string") {
     try {
-      return JSON.stringify(JSON.parse(args), null, 2);
-    } catch (e) {
-      return args;
+      return JSON.parse(args);
+    } catch {
+      return {};
     }
   }
-  return JSON.stringify(args, null, 2);
+  return args || {};
+};
+var truncate = (str, max) => {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+};
+var getBasename = (filepath) => {
+  const parts = filepath.split("/");
+  return parts[parts.length - 1] || filepath;
 };
 var renderShellCommand2 = ({ args }) => {
-  const command = args.command || "[command not found]";
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs8(Box8, { children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " shell" })
-    ] }),
-    /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: command }) })
+  const parsed = parseArgs(args);
+  const command = parsed.command || "[no command]";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "cyan", bold: true, children: "$" }),
+    /* @__PURE__ */ jsxs8(Text8, { color: "cyan", children: [
+      " ",
+      truncate(command, 70)
+    ] })
   ] });
 };
 var renderLsTool2 = ({ args }) => {
-  let directoryPath = "[path not found]";
-  try {
-    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
-    directoryPath = parsedArgs.directory_path || "[path not specified]";
-  } catch (e) {
-    directoryPath = "Error parsing arguments";
-  }
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs8(Box8, { children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " ls" })
-    ] }),
-    /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: directoryPath }) })
+  const parsed = parseArgs(args);
+  const path17 = parsed.directory_path || ".";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "ls" }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " ",
+      path17
+    ] })
   ] });
 };
 var renderCountFilesLines = ({ args }) => {
-  let filepath = "[path not found]";
-  try {
-    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
-    filepath = parsedArgs.filepath || "[path not specified]";
-  } catch (e) {
-    filepath = "Error parsing arguments";
-  }
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs8(Box8, { children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " count lines" })
-    ] }),
-    /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: filepath }) })
+  const parsed = parseArgs(args);
+  const filepath = parsed.filepath || "[no file]";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "wc -l" }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " ",
+      getBasename(filepath)
+    ] })
   ] });
 };
 var renderReadFileLines2 = ({ args }) => {
-  let filepath = "[path not found]";
-  let startLine = 0;
-  let endLine = 0;
-  try {
-    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
-    filepath = parsedArgs.filepath || "[path not specified]";
-    startLine = parsedArgs.start_line || 0;
-    endLine = parsedArgs.end_line || 0;
-  } catch (e) {
-    filepath = "Error parsing arguments";
-  }
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs8(Box8, { children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " read" })
+  const parsed = parseArgs(args);
+  const filepath = parsed.filepath || "[no file]";
+  const start = parsed.start_line || 1;
+  const end = parsed.end_line || start;
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "cat" }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " ",
+      getBasename(filepath)
     ] }),
-    /* @__PURE__ */ jsxs8(Box8, { paddingLeft: 2, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "gray", children: filepath }),
-      /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
-        "lines ",
-        startLine,
-        " to ",
-        endLine
-      ] }) })
+    /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+      " :",
+      start,
+      "-",
+      end
     ] })
   ] });
 };
 var renderBlumaNotebook = ({ args }) => {
-  try {
-    let dataToParse = args;
-    if (args && typeof args === "object") {
-      if (args.content) dataToParse = args.content;
-      else if (args.data) dataToParse = args.data;
-    }
-    const thinkingData = typeof dataToParse === "string" ? JSON.parse(dataToParse) : dataToParse;
-    if (!thinkingData || typeof thinkingData.thought !== "string") {
-      throw new Error("Invalid thought data");
-    }
-    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(Text8, { bold: true, color: "cyan", children: "\u{1F4AD} Reasoning" }) }),
-      /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: thinkingData.thought }) })
-    ] });
-  } catch (e) {
-    return /* @__PURE__ */ jsx8(Box8, { paddingX: 1, children: /* @__PURE__ */ jsx8(Text8, { color: "red", children: "Error parsing reasoning" }) });
-  }
+  const parsed = parseArgs(args);
+  const thought = parsed.thought || parsed.content?.thought || "[thinking...]";
+  const truncated = truncate(thought, 100);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(Text8, { color: "magenta", dimColor: true, children: "thinking" }) }),
+    /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, italic: true, children: truncated }) })
+  ] });
 };
 var renderEditToolCall = ({ args, preview }) => {
-  let filepath = "[path not specified]";
-  try {
-    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
-    filepath = parsedArgs.file_path || "[path not specified]";
-  } catch (e) {
-    filepath = "Error parsing arguments";
-  }
+  const parsed = parseArgs(args);
+  const filepath = parsed.file_path || "[no file]";
+  const oldStr = parsed.old_string || "";
+  const newStr = parsed.new_string || "";
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsxs8(Box8, { children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " edit " }),
-      /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: filepath })
+      /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "edit" }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        " ",
+        getBasename(filepath)
+      ] })
     ] }),
-    preview && /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(SimpleDiff, { text: preview, maxHeight: Infinity }) })
+    preview ? /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(SimpleDiff, { text: preview, maxHeight: 8 }) }) : /* @__PURE__ */ jsxs8(Box8, { paddingLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs8(Text8, { color: "red", dimColor: true, children: [
+        "- ",
+        truncate(oldStr, 50)
+      ] }),
+      /* @__PURE__ */ jsxs8(Text8, { color: "green", dimColor: true, children: [
+        "+ ",
+        truncate(newStr, 50)
+      ] })
+    ] })
   ] });
 };
 var renderTodoTool2 = ({ args }) => {
-  try {
-    const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
-    const tasks = parsedArgs.tasks || [];
-    if (tasks.length === 0) {
-      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
-        /* @__PURE__ */ jsxs8(Box8, { children: [
-          /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " todo" })
-        ] }),
-        /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "No tasks" }) })
-      ] });
-    }
-    const completed = tasks.filter((t) => t.isComplete === true).length;
-    const pending = tasks.length - completed;
-    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
-      /* @__PURE__ */ jsxs8(Box8, { children: [
-        /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " todo" })
-      ] }),
-      /* @__PURE__ */ jsxs8(Box8, { paddingLeft: 2, flexDirection: "column", children: [
-        tasks.length > 0 && tasks.length <= 10 && /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, flexDirection: "column", marginTop: 1, children: tasks.map((task, idx) => {
-          const isComplete = task.isComplete === true;
-          const checkbox = isComplete ? "[x]" : "[ ]";
-          const description = task.description || "No description";
-          const displayText = description.length > 60 ? description.substring(0, 57) + "..." : description;
-          const color = isComplete ? "gray" : "yellow";
-          return /* @__PURE__ */ jsxs8(
-            Text8,
-            {
-              color,
-              strikethrough: isComplete,
-              dimColor: isComplete,
-              children: [
-                checkbox,
-                " ",
-                displayText
-              ]
-            },
-            idx
-          );
-        }) }),
-        tasks.length > 10 && /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
-          "(",
-          tasks.length,
-          " tasks total - showing summary)"
-        ] }) })
+  const parsed = parseArgs(args);
+  const tasks = parsed.tasks || [];
+  const completed = tasks.filter((t) => t.isComplete === true).length;
+  const pending = tasks.length - completed;
+  const progress = tasks.length > 0 ? Math.round(completed / tasks.length * 100) : 0;
+  const barWidth = 10;
+  const filled = Math.round(progress / 100 * barWidth);
+  const bar = "=".repeat(filled) + " ".repeat(barWidth - filled);
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs8(Box8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "magenta", children: "todo" }),
+      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        " [",
+        bar,
+        "] ",
+        progress,
+        "%"
       ] })
-    ] });
-  } catch (error) {
-    return /* @__PURE__ */ jsx8(Box8, { paddingX: 1, children: /* @__PURE__ */ jsx8(Text8, { color: "red", children: "Error parsing todo" }) });
-  }
+    ] }),
+    tasks.length > 0 && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingLeft: 2, children: [
+      tasks.slice(0, 15).map((task, i) => /* @__PURE__ */ jsxs8(
+        Text8,
+        {
+          color: task.isComplete === true ? "gray" : "white",
+          dimColor: task.isComplete === true,
+          strikethrough: task.isComplete === true,
+          children: [
+            task.isComplete === true ? "[x]" : "[ ]",
+            " ",
+            task.description
+          ]
+        },
+        i
+      )),
+      tasks.length > 15 && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "... +",
+        tasks.length - 15,
+        " more tasks"
+      ] })
+    ] })
+  ] });
+};
+var renderFindByName = ({ args }) => {
+  const parsed = parseArgs(args);
+  const pattern = parsed.pattern || "*";
+  const dir = parsed.directory || ".";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "find" }),
+    /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+      ' "',
+      pattern,
+      '"'
+    ] }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " in ",
+      dir
+    ] })
+  ] });
+};
+var renderGrepSearch = ({ args }) => {
+  const parsed = parseArgs(args);
+  const query = parsed.query || "";
+  const path17 = parsed.path || ".";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "grep" }),
+    /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+      ' "',
+      truncate(query, 30),
+      '"'
+    ] }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " ",
+      path17
+    ] })
+  ] });
+};
+var renderViewFileOutline = ({ args }) => {
+  const parsed = parseArgs(args);
+  const filepath = parsed.file_path || "[no file]";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "outline" }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " ",
+      getBasename(filepath)
+    ] })
+  ] });
+};
+var renderRunCommandAsync = ({ args }) => {
+  const parsed = parseArgs(args);
+  const command = parsed.command || "[no command]";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "async" }),
+    /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: " $" }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " ",
+      truncate(command, 50)
+    ] })
+  ] });
+};
+var renderCommandStatus = ({ args }) => {
+  const parsed = parseArgs(args);
+  const id = parsed.command_id || "[no id]";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "status" }),
+    /* @__PURE__ */ jsxs8(Text8, { children: [
+      " #",
+      id
+    ] })
+  ] });
 };
-var renderGenericToolCall = ({ toolName, args }) => {
-  const formattedArgs = formatArgumentsForDisplay(args);
+var renderTaskBoundary = ({ args }) => {
+  const parsed = parseArgs(args);
+  const name = parsed.task_name || "[no name]";
+  const mode = parsed.mode || "EXECUTION";
+  const status = parsed.task_status || "";
+  const modeColors = {
+    PLANNING: "blue",
+    EXECUTION: "green",
+    VERIFICATION: "yellow"
+  };
+  const modeSymbols = {
+    PLANNING: "P",
+    EXECUTION: "E",
+    VERIFICATION: "V"
+  };
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsxs8(Box8, { children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713" }),
-      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs8(Text8, { color: modeColors[mode] || "gray", bold: true, children: [
+        "[",
+        modeSymbols[mode] || "?",
+        "]"
+      ] }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
         " ",
-        toolName
+        name
       ] })
     ] }),
-    formattedArgs && formattedArgs !== "{}" && /* @__PURE__ */ jsx8(Box8, { paddingLeft: 2, flexDirection: "column", children: formattedArgs.split("\n").slice(0, 3).map((line, index) => /* @__PURE__ */ jsx8(Text8, { color: "gray", children: line }, index)) })
+    status && /* @__PURE__ */ jsx8(Box8, { paddingLeft: 4, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: truncate(status, 60) }) })
+  ] });
+};
+var renderSearchWeb = ({ args }) => {
+  const parsed = parseArgs(args);
+  const query = parsed.query || "[no query]";
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "blue", children: "search" }),
+    /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+      ' "',
+      truncate(query, 40),
+      '"'
+    ] })
+  ] });
+};
+var renderGeneric2 = ({ toolName, args }) => {
+  const parsed = parseArgs(args);
+  const keys = Object.keys(parsed).slice(0, 2);
+  return /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "gray", children: toolName }),
+    keys.length > 0 && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      " ",
+      keys.map((k) => `${k}:${truncate(String(parsed[k]), 20)}`).join(" ")
+    ] })
   ] });
 };
 var ToolRenderDisplay = {
@@ -3613,7 +5525,14 @@ var ToolRenderDisplay = {
   count_file_lines: renderCountFilesLines,
   read_file_lines: renderReadFileLines2,
   edit_tool: renderEditToolCall,
-  todo: renderTodoTool2
+  todo: renderTodoTool2,
+  find_by_name: renderFindByName,
+  grep_search: renderGrepSearch,
+  view_file_outline: renderViewFileOutline,
+  run_command_async: renderRunCommandAsync,
+  command_status: renderCommandStatus,
+  task_boundary: renderTaskBoundary,
+  search_web: renderSearchWeb
 };
 
 // src/app/ui/components/ToolCallDisplay.tsx
@@ -3622,194 +5541,303 @@ var ToolCallDisplayComponent = ({ toolName, args, preview }) => {
   if (toolName.includes("message_notify_user") || toolName.includes("agent_end_turn")) {
     return null;
   }
-  const Renderer = ToolRenderDisplay[toolName] || renderGenericToolCall;
+  const Renderer = ToolRenderDisplay[toolName] || ((props2) => renderGeneric2({ ...props2, toolName }));
   return /* @__PURE__ */ jsx9(Box9, { marginBottom: 1, children: /* @__PURE__ */ jsx9(Renderer, { toolName, args, preview }) });
 };
-var ToolCallDisplay = memo3(ToolCallDisplayComponent);
+var ToolCallDisplay = memo6(ToolCallDisplayComponent);
 
 // src/app/ui/components/ToolResultDisplay.tsx
-import { memo as memo4 } from "react";
-import { Box as Box11 } from "ink";
+import { memo as memo8 } from "react";
+import { Box as Box11, Text as Text10 } from "ink";
 
 // src/app/ui/components/MarkdownRenderer.tsx
+import { memo as memo7 } from "react";
 import { Box as Box10, Text as Text9 } from "ink";
 import { marked } from "marked";
 import { highlight } from "cli-highlight";
-import chalk from "chalk";
-import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var COLORS = {
+  heading: "cyan",
+  code: "gray",
+  link: "blue",
+  quote: "gray",
+  listBullet: "gray"
+};
 function renderTokens(tokens) {
-  const out = [];
-  for (const token of tokens) {
+  const elements = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const key = `token-${i}`;
     switch (token.type) {
       case "heading": {
-        const t = token;
-        const colors = {
-          1: chalk.bold.hex("#0969da"),
-          // Azul GitHub
-          2: chalk.bold.hex("#1a7f37"),
-          // Verde suave
-          3: chalk.bold.hex("#8250df"),
-          // Roxo
-          4: chalk.bold.hex("#cf222e"),
-          // Vermelho
-          5: chalk.bold.hex("#9a6700"),
-          // Amarelo escuro
-          6: chalk.bold.hex("#57606a")
-          // Cinza
-        };
-        out.push(
-          /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Text9, { children: colors[t.depth](`# ${t.text}`) }) }, out.length)
+        const heading = token;
+        const prefix = "#".repeat(heading.depth);
+        elements.push(
+          /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsxs9(Text9, { color: COLORS.heading, bold: true, children: [
+            prefix,
+            " ",
+            heading.text
+          ] }) }, key)
         );
         break;
       }
       case "paragraph": {
-        const p = token;
-        out.push(
-          /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, flexDirection: "row", children: renderInline(p.text) }, out.length)
+        const para = token;
+        elements.push(
+          /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: renderInline(para.text) }, key)
         );
         break;
       }
       case "list": {
-        const l = token;
-        l.items.forEach((item, idx) => {
-          const text = item.tokens ? item.tokens.map((t) => t.type === "text" ? t.text : "").join("") : item.text;
-          out.push(
-            /* @__PURE__ */ jsxs9(Box10, { paddingLeft: 2, children: [
-              /* @__PURE__ */ jsx10(Text9, { color: "white", children: l.ordered ? `${idx + 1}.` : "\u2022" }),
+        const list = token;
+        list.items.forEach((item, idx) => {
+          const bullet = list.ordered ? `${idx + 1}.` : "\u2022";
+          const text = item.tokens?.filter((t) => t.type === "text").map((t) => t.text).join("") || item.text;
+          elements.push(
+            /* @__PURE__ */ jsxs9(Box10, { paddingLeft: 1, children: [
+              /* @__PURE__ */ jsx10(Text9, { color: COLORS.listBullet, children: bullet }),
               /* @__PURE__ */ jsxs9(Text9, { children: [
                 " ",
                 renderInline(text)
               ] })
-            ] }, out.length)
+            ] }, `${key}-item-${idx}`)
           );
         });
-        out.push(/* @__PURE__ */ jsx10(Box10, { marginBottom: 1 }, out.length));
+        elements.push(/* @__PURE__ */ jsx10(Box10, { marginBottom: 1 }, `${key}-spacer`));
         break;
       }
       case "code": {
-        const c = token;
-        const highlighted = highlight(c.text, {
-          language: c.lang ?? "text",
-          ignoreIllegals: true
-        });
-        out.push(
-          /* @__PURE__ */ jsxs9(
-            Box10,
-            {
-              flexDirection: "column",
-              borderStyle: "round",
-              borderColor: "gray",
-              children: [
-                /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Text9, { bold: true, color: "cyan", children: c.lang ?? "code" }) }),
-                /* @__PURE__ */ jsx10(Box10, { children: /* @__PURE__ */ jsx10(Text9, { children: highlighted }) })
-              ]
-            },
-            out.length
-          )
+        const code = token;
+        let highlighted;
+        try {
+          highlighted = highlight(code.text, {
+            language: code.lang || "text",
+            ignoreIllegals: true
+          });
+        } catch {
+          highlighted = code.text;
+        }
+        elements.push(
+          /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", marginBottom: 1, children: [
+            code.lang && /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: code.lang }),
+            /* @__PURE__ */ jsx10(Box10, { paddingLeft: 1, children: /* @__PURE__ */ jsx10(Text9, { children: highlighted }) })
+          ] }, key)
         );
         break;
       }
       case "blockquote": {
-        const b = token;
-        out.push(
-          /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", children: [
-            /* @__PURE__ */ jsx10(Text9, { color: "#0969da", children: "\u2502 " }),
-            /* @__PURE__ */ jsx10(Text9, { dimColor: true, italic: true, children: b.text })
-          ] }, out.length)
+        const quote = token;
+        elements.push(
+          /* @__PURE__ */ jsxs9(Box10, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx10(Text9, { color: COLORS.quote, children: "\u2502 " }),
+            /* @__PURE__ */ jsx10(Text9, { dimColor: true, italic: true, children: quote.text })
+          ] }, key)
         );
         break;
       }
       case "table": {
         const table = token;
-        const headerCells = table.header.map(
-          (cell) => chalk.bold(cell.text)
+        elements.push(
+          /* @__PURE__ */ jsx10(Box10, { flexDirection: "row", children: table.header.map((cell, idx) => /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, children: /* @__PURE__ */ jsx10(Text9, { bold: true, children: cell.text }) }, idx)) }, `${key}-header`)
         );
-        out.push(
-          /* @__PURE__ */ jsx10(Box10, { flexDirection: "row", children: headerCells.map((h, i) => /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, children: /* @__PURE__ */ jsx10(Text9, { children: h }) }, i)) }, out.length)
-        );
-        table.rows.forEach((row) => {
-          out.push(
-            /* @__PURE__ */ jsx10(Box10, { flexDirection: "row", children: row.map((cell, i) => /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, children: /* @__PURE__ */ jsx10(Text9, { children: cell.text }) }, i)) }, out.length)
+        table.rows.forEach((row, rowIdx) => {
+          elements.push(
+            /* @__PURE__ */ jsx10(Box10, { flexDirection: "row", children: row.map((cell, cellIdx) => /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, children: /* @__PURE__ */ jsx10(Text9, { children: cell.text }) }, cellIdx)) }, `${key}-row-${rowIdx}`)
           );
         });
-        out.push(/* @__PURE__ */ jsx10(Box10, { marginBottom: 1 }, out.length));
+        elements.push(/* @__PURE__ */ jsx10(Box10, { marginBottom: 1 }, `${key}-spacer`));
+        break;
+      }
+      case "hr": {
+        elements.push(
+          /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "\u2500".repeat(40) }) }, key)
+        );
         break;
       }
-      default:
-        if (token.text) {
-          out.push(/* @__PURE__ */ jsx10(Text9, { children: token.text }, out.length));
+      case "space": {
+        break;
+      }
+      default: {
+        if ("text" in token && typeof token.text === "string") {
+          elements.push(/* @__PURE__ */ jsx10(Text9, { children: token.text }, key));
         }
+      }
     }
   }
-  return out;
+  return elements;
 }
 function renderInline(text) {
   const parts = [];
-  let rest = text;
-  const regex = /(\*\*(.+?)\*\*|\*(.+?)\*|`(.+?)`|\[(.+?)\]\((.+?)\))/;
-  while (rest.length) {
-    const m = rest.match(regex);
-    if (!m) {
-      parts.push(/* @__PURE__ */ jsx10(Text9, { children: rest }, parts.length));
+  let remaining = text;
+  let partIndex = 0;
+  const inlineRegex = /(\*\*(.+?)\*\*|\*(.+?)\*|`(.+?)`|\[(.+?)\]\((.+?)\))/;
+  while (remaining.length > 0) {
+    const match = remaining.match(inlineRegex);
+    if (!match) {
+      parts.push(/* @__PURE__ */ jsx10(Text9, { children: remaining }, `inline-${partIndex++}`));
       break;
     }
-    const index = m.index ?? 0;
-    if (index > 0)
-      parts.push(/* @__PURE__ */ jsx10(Text9, { children: rest.slice(0, index) }, parts.length));
-    const token = m[0];
-    if (token.startsWith("**")) {
+    const matchIndex = match.index ?? 0;
+    if (matchIndex > 0) {
+      parts.push(
+        /* @__PURE__ */ jsx10(Text9, { children: remaining.slice(0, matchIndex) }, `inline-${partIndex++}`)
+      );
+    }
+    const fullMatch = match[0];
+    if (fullMatch.startsWith("**")) {
       parts.push(
-        /* @__PURE__ */ jsx10(Text9, { bold: true, children: m[2] }, parts.length)
+        /* @__PURE__ */ jsx10(Text9, { bold: true, children: match[2] }, `inline-${partIndex++}`)
       );
-    } else if (token.startsWith("*")) {
+    } else if (fullMatch.startsWith("*")) {
       parts.push(
-        /* @__PURE__ */ jsx10(Text9, { italic: true, children: m[3] }, parts.length)
+        /* @__PURE__ */ jsx10(Text9, { italic: true, children: match[3] }, `inline-${partIndex++}`)
       );
-    } else if (token.startsWith("`")) {
+    } else if (fullMatch.startsWith("`")) {
       parts.push(
-        /* @__PURE__ */ jsx10(Text9, { children: /* @__PURE__ */ jsx10(Text9, { backgroundColor: "#eaeef2", color: "black", children: ` ${m[4]} ` }) }, parts.length)
+        /* @__PURE__ */ jsxs9(Text9, { color: COLORS.code, children: [
+          "`",
+          match[4],
+          "`"
+        ] }, `inline-${partIndex++}`)
       );
-    } else if (token.startsWith("[")) {
+    } else if (fullMatch.startsWith("[")) {
       parts.push(
-        /* @__PURE__ */ jsxs9(Text9, { underline: true, color: "#0969da", children: [
-          m[5],
-          " (",
-          m[6],
-          ")"
-        ] }, parts.length)
+        /* @__PURE__ */ jsx10(Text9, { color: COLORS.link, underline: true, children: match[5] }, `inline-${partIndex++}`)
       );
     }
-    rest = rest.slice(index + token.length);
+    remaining = remaining.slice(matchIndex + fullMatch.length);
   }
-  return parts;
+  return parts.length === 1 ? parts[0] : /* @__PURE__ */ jsx10(Fragment3, { children: parts });
 }
-var MarkdownRenderer = ({ markdown }) => {
+var MarkdownRendererComponent = ({ markdown }) => {
+  if (!markdown || markdown.trim() === "") {
+    return null;
+  }
   const tokens = marked.lexer(markdown);
   return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: renderTokens(tokens) });
 };
+var MarkdownRenderer = memo7(MarkdownRendererComponent);
 
 // src/app/ui/components/ToolResultDisplay.tsx
-import { jsx as jsx11 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+var MAX_LINES = 8;
+var parseResult = (result) => {
+  try {
+    return JSON.parse(result);
+  } catch {
+    return null;
+  }
+};
+var truncateLines = (text, max) => {
+  const allLines = text.split("\n").filter((l) => l.trim());
+  if (allLines.length <= max) {
+    return { lines: allLines, truncated: 0 };
+  }
+  return {
+    lines: allLines.slice(0, max),
+    truncated: allLines.length - max
+  };
+};
 var ToolResultDisplayComponent = ({ toolName, result }) => {
-  if (!toolName.includes("message_notify_user")) {
+  if (toolName.includes("agent_end_turn") || toolName.includes("task_boundary")) {
     return null;
   }
-  try {
-    const parsed = JSON.parse(result);
-    if (parsed.content && parsed.content.body) {
-      const bodyText = parsed.content.body.trim();
-      return /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, paddingX: 1, flexDirection: "column", children: /* @__PURE__ */ jsx11(MarkdownRenderer, { markdown: bodyText }) });
+  const parsed = parseResult(result);
+  if (toolName.includes("message_notify_user")) {
+    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 }) });
+  }
+  if (toolName.includes("read_file") && parsed?.content) {
+    const { lines, truncated } = truncateLines(parsed.content, MAX_LINES);
+    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", paddingLeft: 3, children: [
+      lines.map((line, i) => /* @__PURE__ */ jsx11(Text10, { dimColor: true, color: "gray", children: line.slice(0, 80) }, i)),
+      truncated > 0 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "... +",
+        truncated,
+        " lines"
+      ] })
+    ] });
+  }
+  if ((toolName.includes("shell_command") || toolName.includes("run_command")) && parsed) {
+    const output = parsed.stdout || parsed.output || "";
+    const stderr = parsed.stderr || "";
+    const exitCode = parsed.exit_code ?? parsed.exitCode ?? 0;
+    if (!output && !stderr) return null;
+    const { lines, truncated } = truncateLines(output || stderr, MAX_LINES);
+    const isError = exitCode !== 0 || stderr;
+    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", paddingLeft: 3, children: [
+      lines.map((line, i) => /* @__PURE__ */ jsx11(Text10, { dimColor: true, color: isError ? "red" : "gray", children: line.slice(0, 80) }, i)),
+      truncated > 0 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "... +",
+        truncated,
+        " lines"
+      ] })
+    ] });
+  }
+  if ((toolName.includes("grep") || toolName.includes("find_by_name")) && parsed) {
+    const matches = parsed.matches || parsed.results || parsed.files || [];
+    if (matches.length === 0) {
+      return /* @__PURE__ */ jsx11(Box11, { paddingLeft: 3, children: /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "no matches" }) });
     }
-  } catch (e) {
+    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", paddingLeft: 3, children: [
+      /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        matches.length,
+        " matches"
+      ] }),
+      matches.slice(0, 5).map((m, i) => /* @__PURE__ */ jsxs10(Text10, { dimColor: true, color: "gray", children: [
+        m.file || m.path || m.name || m,
+        m.line ? `:${m.line}` : ""
+      ] }, i)),
+      matches.length > 5 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "... +",
+        matches.length - 5,
+        " more"
+      ] })
+    ] });
+  }
+  if (toolName.includes("ls_tool") && parsed) {
+    const entries = parsed.entries || parsed.files || [];
+    if (entries.length === 0) return null;
+    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", paddingLeft: 3, children: [
+      entries.slice(0, 6).map((e, i) => /* @__PURE__ */ jsxs10(Text10, { dimColor: true, color: e.isDirectory ? "blue" : "gray", children: [
+        e.isDirectory ? "d" : "f",
+        " ",
+        e.name || e
+      ] }, i)),
+      entries.length > 6 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "... +",
+        entries.length - 6,
+        " more"
+      ] })
+    ] });
+  }
+  if (toolName.includes("todo")) {
     return null;
   }
+  if (toolName.includes("view_file_outline") && parsed) {
+    const symbols = parsed.symbols || parsed.outline || [];
+    if (symbols.length === 0) return null;
+    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", paddingLeft: 3, children: [
+      symbols.slice(0, 5).map((s, i) => /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        s.kind || "sym",
+        " ",
+        s.name
+      ] }, i)),
+      symbols.length > 5 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "... +",
+        symbols.length - 5,
+        " more"
+      ] })
+    ] });
+  }
   return null;
 };
-var ToolResultDisplay = memo4(ToolResultDisplayComponent);
+var ToolResultDisplay = memo8(ToolResultDisplayComponent);
 
 // src/app/ui/components/SlashCommands.tsx
 import { Box as Box12, Text as Text11 } from "ink";
-import { Fragment as Fragment3, jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
 var SlashCommands = ({ input, setHistory, agentRef }) => {
   const [cmd, ...args] = input.slice(1).trim().split(/\s+/);
   const outBox = (children) => /* @__PURE__ */ jsx12(
@@ -3831,9 +5859,9 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
     if (cmd === "help") {
       const cmds = getSlashCommands();
       return outBox(
-        /* @__PURE__ */ jsxs10(Fragment3, { children: [
+        /* @__PURE__ */ jsxs11(Fragment4, { children: [
           /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Text11, { bold: true, color: "magenta", children: "Available Commands" }) }),
-          /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", children: cmds.map((c, i) => /* @__PURE__ */ jsxs10(Box12, { children: [
+          /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", children: cmds.map((c, i) => /* @__PURE__ */ jsxs11(Box12, { children: [
             /* @__PURE__ */ jsx12(Text11, { color: "cyan", children: c.name.padEnd(12) }),
             /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: c.description })
           ] }, i)) })
@@ -3843,7 +5871,7 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
     if (cmd === "clear") {
       setHistory((prev) => prev.filter((item) => item.id === 0 || item.id === 1));
       return outBox(
-        /* @__PURE__ */ jsxs10(Box12, { children: [
+        /* @__PURE__ */ jsxs11(Box12, { children: [
           /* @__PURE__ */ jsx12(Text11, { color: "green", children: "\u2713" }),
           /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: " History cleared" })
         ] })
@@ -3857,7 +5885,7 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
           setHistory((prev) => prev.concat({
             id: Date.now(),
             component: outBox(
-              /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsxs10(Text11, { color: "red", children: [
+              /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsxs11(Text11, { color: "red", children: [
                 "\u2716 Failed to execute /init: ",
                 e?.message || String(e)
               ] }) })
@@ -3878,29 +5906,29 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
       const colType = 10;
       const colSource = 18;
       return outBox(
-        /* @__PURE__ */ jsxs10(Fragment3, { children: [
-          /* @__PURE__ */ jsxs10(Box12, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs11(Fragment4, { children: [
+          /* @__PURE__ */ jsxs11(Box12, { marginBottom: 1, children: [
             /* @__PURE__ */ jsx12(Text11, { bold: true, color: "magenta", children: "MCP Tools" }),
             /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: " \u2022 " }),
-            /* @__PURE__ */ jsxs10(Text11, { dimColor: true, children: [
+            /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
               tools.length,
               " total"
             ] }),
-            term && /* @__PURE__ */ jsxs10(Fragment3, { children: [
+            term && /* @__PURE__ */ jsxs11(Fragment4, { children: [
               /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: " \u2022 filter: " }),
-              /* @__PURE__ */ jsxs10(Text11, { color: "cyan", children: [
+              /* @__PURE__ */ jsxs11(Text11, { color: "cyan", children: [
                 '"',
                 term,
                 '"'
               ] }),
-              /* @__PURE__ */ jsxs10(Text11, { dimColor: true, children: [
+              /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
                 " \u2022 showing: ",
                 filtered.length
               ] })
             ] })
           ] }),
-          filtered.length === 0 ? /* @__PURE__ */ jsx12(Text11, { color: "yellow", children: "No MCP tools found" }) : /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsxs10(Text11, { color: "gray", children: [
+          filtered.length === 0 ? /* @__PURE__ */ jsx12(Text11, { color: "yellow", children: "No MCP tools found" }) : /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsxs11(Text11, { color: "gray", children: [
               pad("Name", colName),
               " \u2502 ",
               pad("Type", colType),
@@ -3912,7 +5940,7 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
               const name = t.function?.name || t.name || "tool";
               const type = t.function?.name ? "fn" : t.type || "tool";
               const source = t.source || t.provider || "mcp";
-              return /* @__PURE__ */ jsxs10(Text11, { color: "white", children: [
+              return /* @__PURE__ */ jsxs11(Text11, { color: "white", children: [
                 pad(name, colName),
                 " \u2502 ",
                 pad(String(type), colType),
@@ -3935,22 +5963,22 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
       const colType = 10;
       const colSource = 18;
       return outBox(
-        /* @__PURE__ */ jsxs10(Fragment3, { children: [
+        /* @__PURE__ */ jsxs11(Fragment4, { children: [
           /* @__PURE__ */ jsx12(Text11, { color: "magenta", bold: true, children: "Native Tools" }),
-          /* @__PURE__ */ jsxs10(Text11, { color: "gray", children: [
+          /* @__PURE__ */ jsxs11(Text11, { color: "gray", children: [
             "Total Native: ",
             tools.length,
             term ? `  |  Filter: "${term}"  |  Showing: ${filtered.length}` : ""
           ] }),
-          filtered.length === 0 ? /* @__PURE__ */ jsx12(Text11, { color: "yellow", children: "No native tools to display." }) : /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsxs10(Text11, { color: "gray", children: [
+          filtered.length === 0 ? /* @__PURE__ */ jsx12(Text11, { color: "yellow", children: "No native tools to display." }) : /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs11(Text11, { color: "gray", children: [
               pad("Name", colName),
               " | ",
               pad("Type", colType),
               " | ",
               pad("Source", colSource)
             ] }),
-            /* @__PURE__ */ jsxs10(Text11, { color: "gray", children: [
+            /* @__PURE__ */ jsxs11(Text11, { color: "gray", children: [
               "".padEnd(colName, "-"),
               "---",
               "".padEnd(colType, "-"),
@@ -3961,7 +5989,7 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
               const name = t.function?.name || t.name || "tool";
               const type = t.function?.name ? "fn" : t.type || "tool";
               const source = t.source || "native";
-              return /* @__PURE__ */ jsxs10(Text11, { color: "white", children: [
+              return /* @__PURE__ */ jsxs11(Text11, { color: "white", children: [
                 pad(name, colName),
                 " | ",
                 pad(String(type), colType),
@@ -3973,34 +6001,36 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
         ] })
       );
     }
-    return outBox(/* @__PURE__ */ jsxs10(Text11, { color: "red", children: [
+    return outBox(/* @__PURE__ */ jsxs11(Text11, { color: "red", children: [
       "Command not recognized: /",
       cmd
     ] }));
   };
-  return /* @__PURE__ */ jsx12(Fragment3, { children: render2() });
+  return /* @__PURE__ */ jsx12(Fragment4, { children: render2() });
 };
 var SlashCommands_default = SlashCommands;
 
 // src/app/agent/utils/update_check.ts
 import updateNotifier from "update-notifier";
-import { readPackageUp } from "read-package-up";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import path11 from "path";
-import fs10 from "fs";
-function findPackageJsonNearest(startDir) {
+import path16 from "path";
+import fs12 from "fs";
+var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
+function findBlumaPackageJson(startDir) {
   let dir = startDir;
-  for (let i = 0; i < 6; i++) {
-    const candidate = path11.join(dir, "package.json");
-    if (fs10.existsSync(candidate)) {
+  for (let i = 0; i < 10; i++) {
+    const candidate = path16.join(dir, "package.json");
+    if (fs12.existsSync(candidate)) {
       try {
-        const raw = fs10.readFileSync(candidate, "utf8");
+        const raw = fs12.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
-        if (parsed?.name && parsed?.version) return parsed;
+        if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
+          return { name: parsed.name, version: parsed.version };
+        }
       } catch {
       }
     }
-    const parent = path11.dirname(dir);
+    const parent = path16.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4012,20 +6042,18 @@ async function checkForUpdates() {
       return String(process.env.BLUMA_FORCE_UPDATE_MSG);
     }
     const binPath = process.argv?.[1];
-    let pkg;
-    if (binPath && fs10.existsSync(binPath)) {
-      const candidatePkg = findPackageJsonNearest(path11.dirname(binPath));
-      if (candidatePkg?.name && candidatePkg?.version) {
-        pkg = candidatePkg;
-      }
+    let pkg = null;
+    if (binPath && fs12.existsSync(binPath)) {
+      pkg = findBlumaPackageJson(path16.dirname(binPath));
     }
     if (!pkg) {
       const __filename = fileURLToPath3(import.meta.url);
-      const __dirname = path11.dirname(__filename);
-      const result = await readPackageUp({ cwd: __dirname });
-      pkg = result?.packageJson;
+      const __dirname = path16.dirname(__filename);
+      pkg = findBlumaPackageJson(__dirname);
+    }
+    if (!pkg) {
+      return null;
     }
-    if (!pkg?.name || !pkg?.version) return null;
     const isCI = Boolean(process.env.CI);
     const updateCheckInterval = 0;
     const notifier = updateNotifier({
@@ -4037,20 +6065,19 @@ async function checkForUpdates() {
       const cur = notifier.update.current;
       const lat = notifier.update.latest;
       if (cur && lat && cur !== lat) {
-        return `Update available for ${pkg.name}! ${cur} \u2192 ${lat}
-      Run npm i -g ${pkg.name} to update.`;
+        return `Update available for BluMa CLI! ${cur} \u2192 ${lat}
+Run: npm i -g ${BLUMA_PACKAGE_NAME} to update.`;
       }
     }
     return null;
   } catch (e) {
-    console.warn("Update check failed:", e);
     return null;
   }
 }
 
 // src/app/ui/components/UpdateNotice.tsx
 import { Box as Box13, Text as Text12 } from "ink";
-import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
 function parseUpdateMessage(msg) {
   const lines = msg.split(/\r?\n/).map((l) => l.trim());
   const first = lines[0] || "";
@@ -4069,7 +6096,7 @@ function parseUpdateMessage(msg) {
 }
 var UpdateNotice = ({ message }) => {
   const { name, current, latest, hint } = parseUpdateMessage(message);
-  return /* @__PURE__ */ jsxs11(Box13, { flexDirection: "column", marginBottom: 1, children: [
+  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 }),
     hint ? /* @__PURE__ */ jsx13(Text12, { color: "gray", children: hint }) : null
@@ -4079,54 +6106,93 @@ 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 jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
 var ErrorMessage = ({ message, details, hint }) => {
-  return /* @__PURE__ */ jsxs12(
-    Box14,
-    {
-      borderStyle: "round",
-      borderColor: "red",
-      paddingX: 1,
-      paddingY: 0,
-      flexDirection: "column",
-      marginBottom: 1,
-      children: [
-        /* @__PURE__ */ jsx14(Text13, { color: "red", bold: true, children: "Error" }),
-        /* @__PURE__ */ jsx14(Text13, { color: "red", children: message }),
-        details ? /* @__PURE__ */ jsx14(Text13, { color: "red", dimColor: true, children: details }) : null,
-        hint ? /* @__PURE__ */ jsxs12(Text13, { color: "gray", children: [
-          "Hint: ",
-          hint
-        ] }) : null
-      ]
-    }
-  );
+  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 }) }),
+    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: ",
+      hint
+    ] }) })
+  ] });
 };
 var ErrorMessage_default = ErrorMessage;
 
+// src/app/ui/components/ReasoningDisplay.tsx
+import { memo as memo9, useState as useState5 } from "react";
+import { Box as Box15, Text as Text14 } from "ink";
+import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
+var ReasoningDisplayComponent = ({
+  reasoning,
+  collapsed = false
+}) => {
+  const [isExpanded, setIsExpanded] = useState5(!collapsed);
+  if (!reasoning || reasoning.trim() === "") {
+    return null;
+  }
+  const maxLines = 5;
+  const lines = reasoning.split("\n");
+  const displayText = isExpanded ? reasoning : lines.slice(0, maxLines).join("\n") + (lines.length > maxLines ? "..." : "");
+  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs14(Box15, { children: [
+      /* @__PURE__ */ jsx15(Text14, { color: "white", children: " Thinking" }),
+      lines.length > maxLines && /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+        " [",
+        lines.length,
+        " lines]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx15(Box15, { paddingLeft: 2, flexDirection: "column", children: displayText.split("\n").map((line, i) => /* @__PURE__ */ jsx15(Text14, { color: "gray", dimColor: true, children: line }, i)) })
+  ] });
+};
+var ReasoningDisplay = memo9(ReasoningDisplayComponent);
+
 // src/app/ui/App.tsx
-import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
+var SAFE_AUTO_APPROVE_TOOLS = [
+  // Comunicação/UI
+  "message_notify_user",
+  "agent_end_turn",
+  "todo",
+  "task_boundary",
+  // Leitura de ficheiros (read-only)
+  "ls_tool",
+  "read_file_lines",
+  "count_file_lines",
+  "view_file_outline",
+  "find_by_name",
+  "grep_search",
+  // Status de comandos (read-only)
+  "command_status"
+];
 var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
   const agentInstance = useRef4(null);
-  const [history, setHistory] = useState5([]);
-  const [statusMessage, setStatusMessage] = useState5(
+  const [history, setHistory] = useState6([]);
+  const [statusMessage, setStatusMessage] = useState6(
     "Initializing agent..."
   );
-  const [toolsCount, setToolsCount] = useState5(null);
-  const [mcpStatus, setMcpStatus] = useState5(
+  const [toolsCount, setToolsCount] = useState6(null);
+  const [mcpStatus, setMcpStatus] = useState6(
     "connecting"
   );
-  const [isProcessing, setIsProcessing] = useState5(true);
-  const [pendingConfirmation, setPendingConfirmation] = useState5(
+  const [isProcessing, setIsProcessing] = useState6(true);
+  const [pendingConfirmation, setPendingConfirmation] = useState6(
     null
   );
-  const [confirmationPreview, setConfirmationPreview] = useState5(
+  const [confirmationPreview, setConfirmationPreview] = useState6(
     null
   );
-  const [isInitAgentActive, setIsInitAgentActive] = useState5(false);
+  const [isInitAgentActive, setIsInitAgentActive] = useState6(false);
   const alwaysAcceptList = useRef4([]);
   const workdir = process.cwd();
   const updateCheckRan = useRef4(false);
+  const sessionStartTime = useRef4(Date.now());
+  const [toolCallCount, setToolCallCount] = useState6(0);
   const handleInterrupt = useCallback2(() => {
     if (!isProcessing) return;
     eventBus2.emit("user_interrupt");
@@ -4135,7 +6201,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
       ...prev,
       {
         id: prev.length,
-        component: /* @__PURE__ */ jsx15(Text14, { color: "yellow", children: "-- Task cancelled by dev. --" })
+        component: /* @__PURE__ */ jsx16(Text15, { color: "yellow", children: "-- Task cancelled by dev. --" })
       }
     ]);
   }, [isProcessing, eventBus2]);
@@ -4159,11 +6225,11 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
           ...prev,
           {
             id: prev.length,
-            component: /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsx15(Text14, { color: "white", dimColor: true, children: text }) })
+            component: /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsx16(Text15, { color: "white", dimColor: true, children: text }) })
           },
           {
             id: prev.length + 1,
-            component: /* @__PURE__ */ jsx15(
+            component: /* @__PURE__ */ jsx16(
               SlashCommands_default,
               {
                 input: text,
@@ -4183,8 +6249,8 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
           id: prev.length,
           component: (
             // Uma única Box para o espaçamento
-            /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsxs13(Text14, { color: "white", dimColor: true, children: [
-              /* @__PURE__ */ jsxs13(Text14, { color: "white", children: [
+            /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: "white", dimColor: true, children: [
+              /* @__PURE__ */ jsxs15(Text15, { color: "white", children: [
                 ">",
                 " "
               ] }),
@@ -4219,7 +6285,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
     []
   );
   useEffect5(() => {
-    setHistory([{ id: 0, component: /* @__PURE__ */ jsx15(Header, { sessionId: sessionId2, workdir }) }]);
+    setHistory([{ id: 0, component: /* @__PURE__ */ jsx16(Header, { sessionId: sessionId2, workdir }) }]);
     const initializeAgent = async () => {
       try {
         agentInstance.current = new Agent(sessionId2, eventBus2);
@@ -4248,6 +6314,10 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         }
         if (parsed.type === "confirmation_request") {
           const toolToConfirm = parsed.tool_calls[0].function.name;
+          if (SAFE_AUTO_APPROVE_TOOLS.includes(toolToConfirm)) {
+            handleConfirmation("accept", parsed.tool_calls);
+            return;
+          }
           if (alwaysAcceptList.current.includes(toolToConfirm)) {
             handleConfirmation("accept", parsed.tool_calls);
             return;
@@ -4281,7 +6351,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
                   ...prev,
                   {
                     id: prev.length,
-                    component: /* @__PURE__ */ jsx15(UpdateNotice_default, { message: msg })
+                    component: /* @__PURE__ */ jsx16(UpdateNotice_default, { message: msg })
                   }
                 ]);
               }
@@ -4295,10 +6365,10 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         }
         let newComponent = null;
         if (parsed.type === "debug") {
-          newComponent = /* @__PURE__ */ jsx15(Text14, { color: "gray", children: parsed.message });
+          newComponent = /* @__PURE__ */ jsx16(Text15, { color: "gray", children: parsed.message });
         } else if (parsed.type === "protocol_violation") {
-          newComponent = /* @__PURE__ */ jsxs13(
-            Box15,
+          newComponent = /* @__PURE__ */ jsxs15(
+            Box16,
             {
               borderStyle: "round",
               borderColor: "yellow",
@@ -4306,14 +6376,14 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
               marginBottom: 1,
               paddingX: 1,
               children: [
-                /* @__PURE__ */ jsx15(Text14, { color: "yellow", bold: true, children: "Protocol Violation" }),
-                /* @__PURE__ */ jsx15(Text14, { color: "gray", children: parsed.content }),
-                /* @__PURE__ */ jsx15(Text14, { color: "yellow", children: parsed.message })
+                /* @__PURE__ */ jsx16(Text15, { color: "yellow", bold: true, children: "Protocol Violation" }),
+                /* @__PURE__ */ jsx16(Text15, { color: "gray", children: parsed.content }),
+                /* @__PURE__ */ jsx16(Text15, { color: "yellow", children: parsed.message })
               ]
             }
           );
         } else if (parsed.type === "error") {
-          newComponent = /* @__PURE__ */ jsx15(
+          newComponent = /* @__PURE__ */ jsx16(
             ErrorMessage_default,
             {
               message: parsed.message,
@@ -4322,8 +6392,8 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
             }
           );
         } else if (parsed.type === "tool_call") {
-          const nextId = history.length;
-          newComponent = /* @__PURE__ */ jsx15(
+          const nextId2 = history.length;
+          newComponent = /* @__PURE__ */ jsx16(
             ToolCallDisplay,
             {
               toolName: parsed.tool_name,
@@ -4332,7 +6402,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
             }
           );
         } else if (parsed.type === "tool_result") {
-          newComponent = /* @__PURE__ */ jsx15(
+          newComponent = /* @__PURE__ */ jsx16(
             ToolResultDisplay,
             {
               toolName: parsed.tool_name,
@@ -4340,15 +6410,17 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
             }
           );
         } else if (parsed.type === "user_overlay") {
-          newComponent = /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsxs13(Text14, { color: "gray", children: [
-            /* @__PURE__ */ jsxs13(Text14, { color: "magenta", children: [
+          newComponent = /* @__PURE__ */ jsx16(Box16, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: "gray", children: [
+            /* @__PURE__ */ jsxs15(Text15, { color: "magenta", children: [
               ">",
               " "
             ] }),
             parsed.payload
           ] }) });
+        } else if (parsed.type === "reasoning") {
+          newComponent = /* @__PURE__ */ jsx16(ReasoningDisplay, { reasoning: parsed.content });
         } else if (parsed.type === "log") {
-          newComponent = /* @__PURE__ */ jsxs13(Text14, { color: "gray", children: [
+          newComponent = /* @__PURE__ */ jsxs15(Text15, { color: "gray", children: [
             "\u2139\uFE0F ",
             parsed.message,
             parsed.payload ? `: ${parsed.payload}` : ""
@@ -4381,7 +6453,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
       return;
     }
     if (pendingConfirmation) {
-      return /* @__PURE__ */ jsx15(
+      return /* @__PURE__ */ jsx16(
         ConfirmationPrompt,
         {
           toolCalls: pendingConfirmation,
@@ -4393,9 +6465,9 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         }
       );
     }
-    return /* @__PURE__ */ jsxs13(Box15, { flexDirection: "column", children: [
-      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx15(WorkingTimer, {}),
-      /* @__PURE__ */ jsx15(
+    return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+      isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx16(WorkingTimer, {}),
+      /* @__PURE__ */ jsx16(
         InputPrompt,
         {
           onSubmit: handleSubmit,
@@ -4406,12 +6478,12 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
       )
     ] });
   };
-  return /* @__PURE__ */ jsxs13(Box15, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx15(Static, { items: history, children: (item) => /* @__PURE__ */ jsx15(Box15, { children: item.component }, item.id) }),
+  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx16(Static, { items: history, children: (item) => /* @__PURE__ */ jsx16(Box16, { children: item.component }, item.id) }),
     renderInteractiveComponent()
   ] });
 };
-var App = memo5(AppComponent);
+var App = memo10(AppComponent);
 var App_default = App;
 
 // src/app/ui/utils/terminalTitle.ts
@@ -4473,9 +6545,9 @@ function stopTitleKeeper() {
 var BLUMA_TITLE = process.env.BLUMA_TITLE || "BluMa - NomadEngenuity";
 startTitleKeeper(BLUMA_TITLE);
 var eventBus = new EventEmitter2();
-var sessionId = uuidv42();
+var sessionId = uuidv43();
 var props = {
   eventBus,
   sessionId
 };
-render(React6.createElement(App_default, props));
+render(React10.createElement(App_default, props));