@nomad-e/bluma-cli 0.0.32 → 0.0.34

package/dist/main.js

@@ -6,7 +6,7 @@ import { EventEmitter as EventEmitter2 } from "events";
 import { v4 as uuidv42 } from "uuid";
 
 // src/app/ui/App.tsx
-import { useState as useState4, useEffect as useEffect3, useRef, useCallback, memo as memo4 } from "react";
+import { useState as useState5, useEffect as useEffect4, useRef as useRef2, useCallback, memo as memo4 } from "react";
 import { Box as Box15, Text as Text14, Static } from "ink";
 
 // src/app/ui/layout.tsx
@@ -115,7 +115,7 @@ function inputReducer(state, action, viewWidth) {
   };
   switch (action.type) {
     case "INPUT": {
-      const cleanInput = action.payload.replace(/(\r\n|\n|\r)/gm, "");
+      const cleanInput = action.payload.replace(/(||)/gm, "");
       const newText = state.text.slice(0, state.cursorPosition) + cleanInput + state.text.slice(state.cursorPosition);
       const newCursorPosition = state.cursorPosition + cleanInput.length;
       const newViewStart = adjustView(newCursorPosition, state.viewStart);
@@ -140,6 +140,14 @@ function inputReducer(state, action, viewWidth) {
     case "SUBMIT": {
       return { text: "", cursorPosition: 0, viewStart: 0 };
     }
+    case "SET": {
+      const t = action.payload.text.replace(/(||)/gm, "");
+      const moveToEnd = action.payload.moveCursorToEnd ?? true;
+      const newText = t;
+      const newCursorPosition = moveToEnd ? newText.length : Math.min(state.cursorPosition, newText.length);
+      const newViewStart = adjustView(newCursorPosition, 0);
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
     default:
       return state;
   }
@@ -170,6 +178,13 @@ var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
         return dispatch({ type: "INPUT", payload: input });
       }
       if (key.return) {
+        if (globalThis.__BLUMA_AT_OPEN__) {
+          return;
+        }
+        if (globalThis.__BLUMA_SUPPRESS_SUBMIT__) {
+          globalThis.__BLUMA_SUPPRESS_SUBMIT__ = false;
+          return;
+        }
         if (state.text.trim().length > 0) {
           onSubmit(state.text);
           dispatch({ type: "SUBMIT" });
@@ -188,12 +203,20 @@ var useCustomInput = ({ onSubmit, viewWidth, isReadOnly, onInterrupt }) => {
   return {
     text: state.text,
     cursorPosition: state.cursorPosition,
-    viewStart: state.viewStart
+    viewStart: state.viewStart,
+    setText: (t, pos) => {
+      if (typeof pos === "number") {
+        dispatch({ type: "SET", payload: { text: t, moveCursorToEnd: false, cursorPosition: pos } });
+      } else {
+        dispatch({ type: "SET", payload: { text: t, moveCursorToEnd: true } });
+      }
+    },
+    setCursor: (pos) => dispatch({ type: "SET_CURSOR", payload: pos })
   };
 };
 
 // src/app/ui/components/InputPrompt.tsx
-import { useEffect, useMemo, useState } from "react";
+import { useEffect as useEffect2, useMemo, useState as useState2 } from "react";
 import { EventEmitter } from "events";
 
 // src/app/ui/utils/slashRegistry.ts
@@ -242,16 +265,160 @@ var filterSlashCommands = (query) => {
   return scored.map((s) => s.cmd);
 };
 
+// src/app/ui/hooks/useAtCompletion.ts
+import { useEffect, useRef, useState } from "react";
+import fs from "fs";
+import path from "path";
+var MAX_RESULTS = 50;
+var DEFAULT_RECURSIVE_DEPTH = 2;
+function listPathSuggestions(baseDir, pattern) {
+  const raw = pattern || "";
+  const patternEndsWithSlash = raw.endsWith("/");
+  const relDir = raw.replace(/^\/+|\/+$/g, "");
+  const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
+  const listDir = path.resolve(baseDir, relDir || ".");
+  const results = [];
+  const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
+  const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
+  function isIgnoredName(name) {
+    if (!name) return false;
+    if (IGNORED_DIRS.includes(name)) return true;
+    if (name.startsWith(".")) return true;
+    return false;
+  }
+  function isIgnoredFile(name) {
+    if (!name) return false;
+    for (const e of IGNORED_EXTS) if (name.endsWith(e)) return true;
+    return false;
+  }
+  function pushEntry(entryPath, label, isDir) {
+    if (results.length >= MAX_RESULTS) return;
+    const clean = label.split(path.sep).join("/").replace(/[]+/g, "");
+    results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
+  }
+  try {
+    if (raw.length === 0 || patternEndsWithSlash) {
+      const queue = [{ dir: listDir, depth: 0, rel: relDir }];
+      while (queue.length && results.length < MAX_RESULTS) {
+        const node = queue.shift();
+        try {
+          const entries = fs.readdirSync(node.dir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (isIgnoredName(entry.name)) continue;
+            const entryAbs = path.join(node.dir, entry.name);
+            const entryRel = node.rel ? path.posix.join(node.rel, entry.name) : entry.name;
+            if (entryRel.split("/").includes("node_modules")) continue;
+            if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
+            pushEntry(entryAbs, entryRel, entry.isDirectory());
+            if (entry.isDirectory() && node.depth < DEFAULT_RECURSIVE_DEPTH) {
+              queue.push({ dir: entryAbs, depth: node.depth + 1, rel: node.rel ? node.rel + "/" + entry.name : entry.name + "/" });
+            }
+            if (results.length >= MAX_RESULTS) break;
+          }
+        } catch (e) {
+        }
+      }
+    } else {
+      const entries = fs.readdirSync(listDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (filterPrefix && !entry.name.startsWith(filterPrefix)) continue;
+        if (isIgnoredName(entry.name)) continue;
+        if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
+        const entryAbs = path.join(listDir, entry.name);
+        const label = relDir ? path.posix.join(relDir, entry.name) : entry.name;
+        pushEntry(entryAbs, label, entry.isDirectory());
+        if (results.length >= MAX_RESULTS) break;
+      }
+    }
+  } catch (e) {
+  }
+  return results.slice(0, MAX_RESULTS);
+}
+function useAtCompletion({
+  cwd,
+  text,
+  cursorPosition,
+  setText
+}) {
+  const [open, setOpen] = useState(false);
+  const [selected, setSelected] = useState(0);
+  const [suggestions, setSuggestions] = useState([]);
+  const lastQuery = useRef("");
+  function scanForAt(text2, pos) {
+    const before = text2.slice(0, pos);
+    const m = before.match(/@([\w\/.\-_]*)$/);
+    if (!m) return { pattern: null, insertStart: -1 };
+    return { pattern: m[1] || "", insertStart: m.index + 1 };
+  }
+  function update(newText, newCursor) {
+    const res = scanForAt(newText, newCursor);
+    if (res.pattern !== null && res.pattern.length >= 0) {
+      setOpen(true);
+      globalThis.__BLUMA_AT_OPEN__ = true;
+      const suggs = listPathSuggestions(cwd, res.pattern);
+      setSuggestions(suggs);
+      setSelected(0);
+      lastQuery.current = res.pattern;
+    } else {
+      setOpen(false);
+      globalThis.__BLUMA_AT_OPEN__ = false;
+      setSuggestions([]);
+    }
+  }
+  useEffect(() => {
+    update(text, cursorPosition);
+  }, [text, cursorPosition, cwd]);
+  function insertAtSelection() {
+    if (!open || !suggestions[selected]) return;
+    const res = scanForAt(text, cursorPosition);
+    if (!res || res.insertStart < 0) return;
+    let chosen = suggestions[selected].label;
+    const isDir = suggestions[selected].isDir;
+    chosen = chosen.replace(/\\/g, "/").replace(/\|/g, "");
+    let insertVal = chosen;
+    if (insertVal.includes("/")) {
+      insertVal = insertVal.replace(/\/+$/g, "");
+      const parts = insertVal.split("/");
+      insertVal = parts[parts.length - 1];
+    }
+    if (isDir && !insertVal.endsWith("/")) insertVal = insertVal + "/";
+    const pattern = res.pattern || "";
+    const lastSlash = pattern.lastIndexOf("/");
+    const segmentOffset = lastSlash >= 0 ? lastSlash + 1 : 0;
+    const segmentStart = res.insertStart + segmentOffset;
+    const before = text.slice(0, segmentStart);
+    const after = text.slice(cursorPosition);
+    const newText = before + insertVal + after;
+    setText(newText + (isDir ? "" : " "), true);
+    if (isDir) {
+      setOpen(false);
+      setSuggestions([]);
+      setTimeout(() => {
+        setOpen(true);
+        update(newText, newText.length);
+      }, 0);
+    } else {
+      setOpen(false);
+      setSuggestions([]);
+    }
+  }
+  function close() {
+    setOpen(false);
+    setSuggestions([]);
+  }
+  return { open, suggestions, selected, setSelected, insertAtSelection, close, update };
+}
+
 // src/app/ui/components/InputPrompt.tsx
 import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var uiEventBus = global.__bluma_ui_eventbus__ || new EventEmitter();
 global.__bluma_ui_eventbus__ = uiEventBus;
 var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing = false }) => {
   const { stdout } = useStdout();
-  const [viewWidth, setViewWidth] = useState(() => stdout.columns - 6);
-  const [slashOpen, setSlashOpen] = useState(false);
-  const [slashIndex, setSlashIndex] = useState(0);
-  useEffect(() => {
+  const [viewWidth, setViewWidth] = useState2(() => stdout.columns - 6);
+  const [slashOpen, setSlashOpen] = useState2(false);
+  const [slashIndex, setSlashIndex] = useState2(0);
+  useEffect2(() => {
     const onResize = () => setViewWidth(stdout.columns - 6);
     stdout.on("resize", onResize);
     return () => {
@@ -263,7 +430,7 @@ var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing =
     if (isReadOnly) {
       if (trimmed.length > 0) {
         const payload = trimmed;
-        uiEventBus.emit("dev_overlay", { kind: "message", payload, ts: Date.now() });
+        uiEventBus.emit("user_overlay", { kind: "message", payload, ts: Date.now() });
         return;
       }
       return;
@@ -271,9 +438,11 @@ var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing =
     onSubmit(value);
   };
   const effectiveReadOnly = isReadOnly;
-  const { text, cursorPosition, viewStart } = useCustomInput({
+  const { text, cursorPosition, viewStart, setText } = useCustomInput({
+    // Sobrepõe a lógica padrão: nunca submete se autocomplete aberto
     onSubmit: (value) => {
       if (disableWhileProcessing && isReadOnly) return;
+      if (pathAutocomplete.open) return;
       permissiveOnSubmit(value);
     },
     viewWidth,
@@ -294,7 +463,7 @@ var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing =
     if (!slashQuery) return [];
     return filterSlashCommands(slashQuery);
   }, [slashQuery]);
-  useEffect(() => {
+  useEffect2(() => {
     if (isReadOnly) {
       setSlashOpen(false);
       return;
@@ -317,12 +486,51 @@ var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing =
       if (choice) {
         const cmd = choice.name;
         setSlashOpen(false);
-        permissiveOnSubmit(cmd);
+        try {
+          setText(`${cmd} `, true);
+        } catch (e) {
+          permissiveOnSubmit(`${cmd} `);
+        }
       }
     } else if (key.escape) {
       setSlashOpen(false);
     }
   }, { isActive: slashOpen });
+  const cwd = process.cwd();
+  const pathAutocomplete = useAtCompletion({ cwd, text, cursorPosition, setText });
+  useInput2((input, key) => {
+    if (pathAutocomplete.open) {
+      if (key.downArrow) {
+        pathAutocomplete.setSelected((i) => Math.min(i + 1, Math.max(0, pathAutocomplete.suggestions.length - 1)));
+        return;
+      } else if (key.upArrow) {
+        pathAutocomplete.setSelected((i) => Math.max(i - 1, 0));
+        return;
+      } else if (key.return || key.tab) {
+        const selected = pathAutocomplete.suggestions[pathAutocomplete.selected];
+        if (selected) {
+          const before = text.slice(0, cursorPosition);
+          const m = before.match(/@([\w\/.\-_]*)$/);
+          if (m) {
+            globalThis.__BLUMA_SUPPRESS_SUBMIT__ = true;
+            pathAutocomplete.insertAtSelection();
+          }
+        }
+        return;
+      } else if (key.escape) {
+        pathAutocomplete.close();
+        return;
+      }
+      return;
+    }
+  }, { isActive: true });
+  function canSubmitGivenCursor() {
+    if (visibleCursorPosition < visibleText.length) {
+      return visibleText[visibleCursorPosition] === " ";
+    } else {
+      return false;
+    }
+  }
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
     disableWhileProcessing ? (
       // Modo bloqueado visualmente, mantendo hooks estáveis
@@ -343,6 +551,22 @@ var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing =
         /* @__PURE__ */ jsx2(Text2, { inverse: true, children: cursorGlyph }),
         showPlaceholder ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: placeholder }) : /* @__PURE__ */ jsx2(Text2, { children: textAfterCursor })
       ] }) }),
+      pathAutocomplete.open && pathAutocomplete.suggestions.length > 0 && (() => {
+        const VISIBLE = 7;
+        const total = pathAutocomplete.suggestions.length;
+        const sel = Math.max(0, Math.min(pathAutocomplete.selected, total - 1));
+        let start = Math.max(0, sel - Math.floor(VISIBLE / 2));
+        if (start + VISIBLE > total) start = Math.max(0, total - VISIBLE);
+        const windowItems = pathAutocomplete.suggestions.slice(start, start + VISIBLE);
+        return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, height: Math.min(VISIBLE, total), overflowY: "auto", children: windowItems.map((s, idx) => {
+          const realIdx = start + idx;
+          const isSelected = realIdx === pathAutocomplete.selected;
+          return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 1, paddingY: 0, children: [
+            /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "cyan" : "gray", children: isSelected ? "\u276F " : "  " }),
+            /* @__PURE__ */ jsx2(Text2, { color: isSelected ? "cyan" : "white", bold: isSelected, dimColor: !isSelected, children: s.label })
+          ] }, s.fullPath);
+        }) });
+      })(),
       slashOpen && slashSuggestions.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: slashSuggestions.map((s, idx) => {
         const isSelected = idx === slashIndex;
         return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 1, paddingY: 0, children: [
@@ -369,7 +593,7 @@ var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing =
 import { Box as Box6, Text as Text6 } from "ink";
 
 // src/app/ui/InteractiveMenu.tsx
-import { useState as useState2, memo } from "react";
+import { useState as useState3, memo } 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 }) => {
@@ -378,7 +602,7 @@ var InteractiveMenuComponent = ({ onDecision }) => {
     { label: "2. No, cancel this command", value: "decline" },
     { label: "3. Always allow this type of command", value: "accept_always" }
   ];
-  const [selectedOption, setSelectedOption] = useState2(0);
+  const [selectedOption, setSelectedOption] = useState3(0);
   useInput3((input, key) => {
     if (key.upArrow) {
       setSelectedOption((prev) => prev > 0 ? prev - 1 : options.length - 1);
@@ -419,7 +643,7 @@ var InteractiveMenu = memo(InteractiveMenuComponent);
 
 // src/app/ui/components/promptRenderers.tsx
 import { Box as Box5, Text as Text5 } from "ink";
-import path from "path";
+import path2 from "path";
 
 // src/app/ui/components/SimpleDiff.tsx
 import { Box as Box4, Text as Text4 } from "ink";
@@ -458,7 +682,7 @@ var SimpleDiff = ({ text, maxHeight }) => {
 // src/app/ui/components/promptRenderers.tsx
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var getBasePath = (filePath) => {
-  return path.basename(filePath);
+  return path2.basename(filePath);
 };
 var renderShellCommand = ({
   toolCall
@@ -626,12 +850,12 @@ var ConfirmationPrompt = ({ toolCalls, preview, onDecision }) => {
 // src/app/agent/agent.ts
 import OpenAI from "openai";
 import * as dotenv from "dotenv";
-import path8 from "path";
+import path9 from "path";
 import os6 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs5 } from "fs";
-import path4 from "path";
+import { promises as fs6 } from "fs";
+import path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/agent/tools/natives/shell_command.ts
@@ -699,8 +923,8 @@ ${stderr.trim()}`.trim();
 }
 
 // src/app/agent/tools/natives/edit.ts
-import path2 from "path";
-import { promises as fs } from "fs";
+import path3 from "path";
+import { promises as fs2 } from "fs";
 import { diffLines } from "diff";
 function unescapeLlmString(inputString) {
   return inputString.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, "\\");
@@ -736,7 +960,7 @@ async function calculateEdit(filePath, oldString, newString, expectedReplacement
   let finalOldString = oldString.replace(/\r\n/g, "\n");
   let occurrences = 0;
   try {
-    currentContent = await fs.readFile(filePath, "utf-8");
+    currentContent = await fs2.readFile(filePath, "utf-8");
     currentContent = currentContent.replace(/\r\n/g, "\n");
   } catch (e) {
     if (e.code !== "ENOENT") {
@@ -792,7 +1016,7 @@ function createDiff(filename, oldContent, newContent) {
 }
 async function editTool(args) {
   const { file_path, old_string, new_string, expected_replacements = 1 } = args;
-  if (!path2.isAbsolute(file_path)) {
+  if (!path3.isAbsolute(file_path)) {
     return { success: false, error: `Invalid parameters: file_path must be absolute.`, file_path };
   }
   if (file_path.includes("..")) {
@@ -808,10 +1032,10 @@ async function editTool(args) {
         file_path
       };
     }
-    await fs.mkdir(path2.dirname(file_path), { recursive: true });
-    await fs.writeFile(file_path, editData.newContent, "utf-8");
-    const relativePath = path2.relative(process.cwd(), file_path);
-    const filename = path2.basename(file_path);
+    await fs2.mkdir(path3.dirname(file_path), { recursive: true });
+    await fs2.writeFile(file_path, editData.newContent, "utf-8");
+    const relativePath = path3.relative(process.cwd(), file_path);
+    const filename = path3.basename(file_path);
     if (editData.isNewFile) {
       return {
         success: true,
@@ -846,10 +1070,10 @@ ${finalDiff}`,
 
 // src/app/agent/tools/natives/message.ts
 import { v4 as uuidv4 } from "uuid";
-function messageNotifyDev(args) {
+function messageNotifyuser(args) {
   const { text_markdown } = args;
   const notification = {
-    type: "message_notify_dev",
+    type: "message_notify_user",
     id: `notify_${uuidv4()}`,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     content: {
@@ -863,8 +1087,8 @@ function messageNotifyDev(args) {
 }
 
 // src/app/agent/tools/natives/ls.ts
-import { promises as fs2 } from "fs";
-import path3 from "path";
+import { promises as fs3 } from "fs";
+import path4 from "path";
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   ".git",
   ".gitignore",
@@ -892,8 +1116,8 @@ async function ls(args) {
     max_depth
   } = args;
   try {
-    const basePath = path3.resolve(directory_path);
-    if (!(await fs2.stat(basePath)).isDirectory()) {
+    const basePath = path4.resolve(directory_path);
+    if (!(await fs3.stat(basePath)).isDirectory()) {
       throw new Error(`Directory '${directory_path}' not found.`);
     }
     const allIgnorePatterns = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore_patterns]);
@@ -902,11 +1126,11 @@ async function ls(args) {
     const allDirs = [];
     const walk = async (currentDir, currentDepth) => {
       if (max_depth !== void 0 && currentDepth > max_depth) return;
-      const entries = await fs2.readdir(currentDir, { withFileTypes: true });
+      const entries = await fs3.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         const entryName = entry.name;
-        const fullPath = path3.join(currentDir, entryName);
-        const posixPath = fullPath.split(path3.sep).join("/");
+        const fullPath = path4.join(currentDir, entryName);
+        const posixPath = fullPath.split(path4.sep).join("/");
         const isHidden = entryName.startsWith(".");
         if (allIgnorePatterns.has(entryName) || isHidden && !show_hidden) {
           continue;
@@ -917,7 +1141,7 @@ async function ls(args) {
             await walk(fullPath, currentDepth + 1);
           }
         } else if (entry.isFile()) {
-          if (!normalizedExtensions || normalizedExtensions.includes(path3.extname(entryName).toLowerCase())) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path4.extname(entryName).toLowerCase())) {
             allFiles.push(posixPath);
           }
         }
@@ -928,7 +1152,7 @@ async function ls(args) {
     allDirs.sort();
     return {
       success: true,
-      path: basePath.split(path3.sep).join("/"),
+      path: basePath.split(path4.sep).join("/"),
       recursive,
       total_files: allFiles.length,
       total_directories: allDirs.length,
@@ -944,17 +1168,17 @@ async function ls(args) {
 }
 
 // src/app/agent/tools/natives/readLines.ts
-import { promises as fs3 } from "fs";
+import { promises as fs4 } from "fs";
 async function readLines(args) {
   const { filepath, start_line, end_line } = args;
   try {
-    if (!(await fs3.stat(filepath)).isFile()) {
+    if (!(await fs4.stat(filepath)).isFile()) {
       throw new Error(`File '${filepath}' not found or is not a file.`);
     }
     if (start_line < 1 || end_line < start_line) {
       throw new Error("Invalid line range. start_line must be >= 1 and end_line must be >= start_line.");
     }
-    const fileContent = await fs3.readFile(filepath, "utf-8");
+    const fileContent = await fs4.readFile(filepath, "utf-8");
     const lines = fileContent.split("\n");
     const total_lines = lines.length;
     const startIndex = start_line - 1;
@@ -982,12 +1206,12 @@ async function readLines(args) {
 
 // src/app/agent/tools/natives/count_lines.ts
 import { createReadStream } from "fs";
-import { promises as fs4 } from "fs";
+import { promises as fs5 } from "fs";
 import readline from "readline";
 async function countLines(args) {
   const { filepath } = args;
   try {
-    if (!(await fs4.stat(filepath)).isFile()) {
+    if (!(await fs5.stat(filepath)).isFile()) {
       throw new Error(`File '${filepath}' not found or is not a file.`);
     }
     const fileStream = createReadStream(filepath);
@@ -1022,9 +1246,9 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path4.dirname(__filename);
-      const configPath = path4.resolve(__dirname, "config", "native_tools.json");
-      const fileContent = await fs5.readFile(configPath, "utf-8");
+      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) {
@@ -1039,7 +1263,7 @@ var ToolInvoker = class {
   registerTools() {
     this.toolImplementations.set("shell_command", shellCommand);
     this.toolImplementations.set("edit_tool", editTool);
-    this.toolImplementations.set("message_notify_dev", messageNotifyDev);
+    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);
@@ -1073,8 +1297,8 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs6 } from "fs";
-import path5 from "path";
+import { promises as fs7 } from "fs";
+import path6 from "path";
 import os2 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -1102,9 +1326,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    const __dirname = path5.dirname(__filename);
-    const defaultConfigPath = path5.resolve(__dirname, "config", "bluma-mcp.json");
-    const userConfigPath = path5.join(os2.homedir(), ".bluma-cli", "bluma-mcp.json");
+    const __dirname = path6.dirname(__filename);
+    const defaultConfigPath = path6.resolve(__dirname, "config", "bluma-mcp.json");
+    const userConfigPath = path6.join(os2.homedir(), ".bluma-cli", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -1138,7 +1362,7 @@ var MCPClient = class {
   }
   async loadMcpConfig(configPath, configType) {
     try {
-      const fileContent = await fs6.readFile(configPath, "utf-8");
+      const fileContent = await fs7.readFile(configPath, "utf-8");
       const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
@@ -1273,12 +1497,12 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/app/agent/session_manger/session_manager.ts
-import path6 from "path";
+import path7 from "path";
 import os3 from "os";
-import { promises as fs7 } from "fs";
+import { promises as fs8 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -1296,13 +1520,13 @@ async function withFileLock(file, fn) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path6.join(os3.homedir(), p.slice(1));
+    return path7.join(os3.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path6.join(os3.homedir(), ".bluma-cli");
-  return path6.resolve(expandHome(fixed));
+  const fixed = path7.join(os3.homedir(), ".bluma-cli");
+  return path7.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -1310,7 +1534,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      await fs7.rename(src, dest);
+      await fs8.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -1323,9 +1547,9 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    const data = await fs7.readFile(src);
-    await fs7.writeFile(dest, data);
-    await fs7.unlink(src).catch(() => {
+    const data = await fs8.readFile(src);
+    await fs8.writeFile(dest, data);
+    await fs8.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -1334,16 +1558,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path6.join(appDir, "sessions");
-  await fs7.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path7.join(appDir, "sessions");
+  await fs8.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadOrcreateSession(sessionId2) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path6.join(sessionDir, `${sessionId2}.json`);
+  const sessionFile = path7.join(sessionDir, `${sessionId2}.json`);
   try {
-    await fs7.access(sessionFile);
-    const fileContent = await fs7.readFile(sessionFile, "utf-8");
+    await fs8.access(sessionFile);
+    const fileContent = await fs8.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     return [sessionFile, sessionData.conversation_history || []];
   } catch (error) {
@@ -1352,7 +1576,7 @@ async function loadOrcreateSession(sessionId2) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
-    await fs7.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    await fs8.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     return [sessionFile, []];
   }
 }
@@ -1360,12 +1584,12 @@ async function saveSessionHistory(sessionFile, history) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path6.dirname(sessionFile);
-      await fs7.mkdir(dir, { recursive: true });
+      const dir = path7.dirname(sessionFile);
+      await fs8.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs7.readFile(sessionFile, "utf-8");
+      const fileContent = await fs8.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -1376,14 +1600,14 @@ async function saveSessionHistory(sessionFile, history) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId2 = path6.basename(sessionFile, ".json");
+      const sessionId2 = path7.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId2,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs7.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs8.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -1391,7 +1615,7 @@ async function saveSessionHistory(sessionFile, history) {
     sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs7.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs8.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -1400,7 +1624,7 @@ async function saveSessionHistory(sessionFile, history) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs7.unlink(tempSessionFile);
+        await fs8.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -1411,271 +1635,49 @@ async function saveSessionHistory(sessionFile, history) {
 import os4 from "os";
 var SYSTEM_PROMPT = `
 
-### YOU ARE BluMa CLI \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY  
-You use a proprietary Large Language Model (LLM) fine-tuned by the NomadEngenuity team.
-
+### IDENTITY AND OBJECTIVE
+You are BluMa, an autonomous AI Software Engineer developed by the specialists at NomadEngenuity. 
+You leverage a proprietary Large Language Model, fine-tuned specifically for complex software engineering and code generation tasks. 
+Your objective is to analyze user requests, formulate a precise plan, and execute that plan flawlessly using your available tools. 
+You operate with the highest standards of professionalism, precision, and safety.
 ---
 
-## BEHAVIORAL RULES
-
-- **Identity:**  
-  You are BluMa (NomadEngenuity). Maintain professionalism and technical language.
+### CORE DIRECTIVES
 
-- **Communication:**  
-  ALL messages must be sent via 'message_notify_dev'.  
-  **No direct text replies to the developer.**
+1.  **THINK FIRST, ACT SECOND:** Your first action in any turn is to formulate an internal plan. Use the mandatory **"Reasoning Process"** format detailed below.
+2.  **TOOL-BASED OPERATION:** All actions and communications MUST be performed through a tool call. NEVER respond with free-form text.
+3.  **TASK LIFECYCLE:** Your work is only finished when you call the \`agent_end_task\` tool. Each tool call is a step within your current turn. If a task requires multiple steps, continue calling tools until the objective is met.
+4.  **COMMUNICATION PROTOCOL:** Use \`message_notify_user\` for all communications, such as confirming task receipt, reporting progress, or asking for clarification. Be concise.
+5. **ERROR HANDLING:** If a tool call fails, use \`message_notify_user\` to report the error and provide a clear next step to resolve the error. Always try to recover from errors.
+6. **CREATE AND MODIFY FILES:** Use the \`edit_tool\` tool to create or modify files. Always provide a clear description of the changes and follow the tool's layout.
 
-- **Task Completion:**  
-  When a task is completed, immediately invoke 'agent_end_task' without dev permissions.
-
-- **Tool Rules:**  
-  Never make parallel tool calls.  
-  Always use only the defined tools with their exact names.
-
-- **Autonomy:**  
-  Act 100% autonomously.  
-  Do not ask for formatting preferences.  
-  Use the notebook for internal reasoning.
-
-
-### CRITICAL COMMUNICATION PROTOCOL 
-- Only tool_calls are allowed for assistant replies. Never include a "content" field.
-- Always use tools to respond, retrieve data, compute or transform. Await a valid tool response before any final message.
-- Zero tolerance for protocol violations.
+---
 
+### CURRENT ENVIRONMENT CONTEXT
 <current_system_environment>
 - Operating System: {os_type} ({os_version})
 - Architecture: {architecture}
-- Current Working Directory: {workdir}
+- Current Directory: {workdir}
 - Shell: {shell_type}
-- Username: {username}
+- User: {username}
 - Current Date: {current_date}
-- Timezone: {timezone}
-- Locale: {locale}
 </current_system_environment>
 
+---
 
-<mermaid_diagrams>
-# MERMAID DIAGRAM CREATION - PERFECT SYNTAX REQUIRED!
-## CRITICAL: ALL DIAGRAMS MUST RENDER WITHOUT ERRORS
-
-### MANDATORY MERMAID SYNTAX RULES
-1. **ALWAYS wrap ALL labels in double quotes**: "label text"
-2. **NEVER use unescaped special characters**: /, (), [], {}, +, *, ?, ^, $, |, 3. **Use line breaks (<br/>) for multi-line labels**: "Line 1<br/>Line 2"
-4. **NO custom colors or ::: syntax**: Stick to standard themes
-5. **NO beta features**: Use only stable Mermaid syntax
-6. **NO remote images**: Never embed external images
-
-### SAFE LABEL FORMATTING
-
-CORRECT:
-- "dev Authentication"
-- "API Gateway (REST)"
-- "Database Connection<br/>MySQL 8.0"
-- "Process Data<br/>Transform & Validate"
-
-INCORRECT:
-- dev Authentication (missing quotes)
-- API Gateway (REST) (parentheses without quotes)
-- Database/MySQL (slash without quotes)
-- Process & Transform (ampersand without quotes)
-
-
-### DIAGRAM TYPE BEST PRACTICES
-
-IMPORTANT
-The Notion API rejects rich text of type "code" and only accepts "text" for code blocks \u2013
-a limitation of their own JSON (even for the language: "mermaid"). Therefore, only the code/text block
-type is viable.
-
-You should insert the pretty diagram without any delimiters or headers, in the code block with
-proper indentation and double quotes, only in the text field, to facilitate as little manual rework as possible.
-It's ready to copy into the native Mermaid block.
-
-#### FLOWCHART
-
-flowchart TD
-    A["Start Process"] --> B["Validate Input"]
-    B --> C{"Is Valid?"}
-    C -->|"Yes"| D["Process Data"]
-    C -->|"No"| E["Return Error"]
-    D --> F["Save to Database"]
-    F --> G["Send Response"]
-
-
-#### SEQUENCE DIAGRAM
-
-sequenceDiagram
-    participant U as "dev"
-    participant A as "API Gateway"
-    participant D as "Database"
-    
-    U->>A: "Submit Request"
-    A->>D: "Query Data"
-    D-->>A: "Return Results"
-    A-->>U: "Response Data"
-
-#### CLASS DIAGRAM
-
-classDiagram
-    class dev {
-        +String name
-        +String email
-        +authenticate()
-        +updateProfile()
-    }
-    
-    class Database {
-        +connect()
-        +query()
-        +close()
-    }
-    
-    dev --> Database : "uses"
-
-
-### VALIDATION CHECKLIST
-Before creating any diagram, ensure:
-- [ ] All labels are wrapped in double quotes
-- [ ] No unescaped special characters (/, (), etc.)
-- [ ] Line breaks use <br/> syntax
-- [ ] No custom colors or styling
-- [ ] No beta features or experimental syntax
-- [ ] All connections use proper arrow syntax
-- [ ] Node IDs are simple alphanumeric
-
-### ERROR PREVENTION
-- Always test diagram syntax mentally before generating
-- Use simple, descriptive labels without special formatting
-- Prefer clarity over visual complexity
-- Keep diagrams focused and readable
-- Use standard Mermaid themes only
-
-## ZERO TOLERANCE FOR SYNTAX ERRORS
-Every diagram MUST render perfectly on first try. No exceptions.
-</mermaid_diagrams>
-                       
+### COMMUNICATION PROTOCOL        
 <message_rules>
-- Communicate with dev's via message tools instead of direct text responses
+- Communicate with user's via message tools instead of direct text responses
 - Reply immediately to new user messages before other operations
 - First reply must be brief, only confirming receipt without specific solutions
-- Notify dev's with brief explanation when changing methods or strategies
-- Message tools are divided into notify (non-blocking, no reply needed from dev's) and ask (blocking, reply required)
-- Actively use notify for progress updates, but reserve ask for only essential needs to minimize dev's disruption and avoid blocking progress
-- Must message dev's with results and deliverables before upon task completion 'agent_end_task'
+- Notify user's with brief explanation when changing methods or strategies
+- Message tools are divided into notify (non-blocking, no reply needed from user's) and ask (blocking, reply required)
+- Actively use notify for progress updates, but reserve ask for only essential needs to minimize user's disruption and avoid blocking progress
+- Must message user's with results and deliverables before upon task completion 'agent_end_task'
 </message_rules>
 
-
-### Live Development Overlaps
-
-        During your workflow, the programmer {username} may send messages at any time.  
-        These messages **must be immediately incorporated** into your execution flow.  
-        **Always confirm receipt using {message_notify_dev}** and proceed with your work.
-
-        ### Instructions for Handling Messages from the Programmer
-
-        1. **Upon receiving a message from {username}:**
-          - Immediately confirm using {message_notify_dev}.
-          - Integrate the instruction into your reasoning and execution flow.
-
-        2. **Regarding your reasoning:**
-          - Be direct, minimalist, and clear.
-          - Avoid unnecessary or verbose thoughts.
-
-        3. **Avoid polluting the history:**
-          - **Do not repeat or reply to existing messages.**
-          - Only act if the new message introduces a **new instruction or shifts the current task\u2019s focus**.
-                       
-<reasoning_rules>
-# YOUR THINKING ON A NOTEBOOK - MANDATORY USE
-CRITICAL: Your laptop (**reasoning_nootebook**) is your ORGANIZED MIND
-## IMPORTANT
-## NEVER PUT CHECKLISTS OR STEPS IN THE THOUGHT TEXT
-## ALWAYS USE A NOTEBOOK (Always for):
-- ANY task
-- Before starting development (plan first!)
-- Projects with multiple files (organize the structure)
-- Debugging sessions (monitor discoveries)
-- Extensive refactoring (map the changes)
-- Architectural decisions (think through the options)
-
-## HOW TO USE A NOTEBOOK:
-1. Start with **reasoning_nootebook**
-2. Break the task down into logical steps
-3. Plan the approach - Which files? What changes? What order? 4. Track progress - Check off completed steps
-5. Write down decisions - Why did you choose this approach?
-6. Update continuously - Keep the notebook up to date
-
-## THE NOTEBOOK PREVENTS:
-- Acting "outside the box"
-- Forgetting task requirements
-- Losing control of complex workflows
-- Making unplanned changes
-- Ineffective approaches
-- Working without a clear roadmap
-- Jumping between unrelated subtasks
-
-	##Important rule:
-	Do **not** include any future steps, to-do items, or pending tasks here.
-	Those belong strictly in the **remaining_tasks** field.
-
-	Never write phrases like:
-	- "Next I will..."
-	- "I still need to..."
-	- "Pending: ..."
-	Such content must go in **remaining_tasks**, not **thought**.
-
-- remaining_tasks: Checklist-style list of high-level upcoming tasks.
-	This format is **mandatory**:
-	- Each task **must start** with either:
-	- "\u{1F5F8}" \u2192 for tasks not yet done (pending)
-	- "[ ]" \u2192 for tasks that have already been completed
-
-	Whenever a task is already done, it **must** be marked with "\u{1F5F8}". Do not leave completed tasks without the checkmark.
-
-	Do not use other formats like "-", "*", or plain text without the prefix.
-
-	Examples:
-	\u{1F5F8} Test integration flow
-	\u{1F5F8} Set up environment
-	[ ] Configure database
-
-</reasoning_rules>
-
-### Tool Naming Policy
-
-Tool names must strictly follow the standard naming format:
-
-- Use: plain, unmodified, lowercase names
-- Do NOT use: special characters, extra spaces, version suffixes, or dynamic IDs
-
 ---
 
-Correct Examples:
-- bluma_notebook
-- getDataTool
-- convertImage
-- userAuth
-
----
-
-Incorrect Examples:
-- reasoning_nootebook:0       \u2190 contains colon and dynamic suffix
-- reasoning_nootebook 1       \u2190 contains space and number
-- reasoning_nootebook#v2      \u2190 contains special character #
-- bluma__nootebook        \u2190 double underscore
-- reasoning_nootebook         \u2190 capital letters and underscore
-- bluma nootebook         \u2190 contains space
-
----
-
-Rule Summary:
-- Use only a\u2013z, 0\u20139, and underscores (_)
-- Do not append suffixes like :0, :v2, etc.
-- Tool names must be static and predictable
-- No whitespace, no dynamic elements, no special characters
-
-
 <edit_tool_rules>  
 - Use this tool to perform precise text replacements inside files based on exact literal matches.
 - Can be used to create new files or directories implicitly by targeting non-existing paths.
@@ -1690,41 +1692,28 @@ Rule Summary:
 - Track all progress related to planning and execution inside todo.md using text replacement only.
 </edit_tool_rules>
 
-Real-Time Developer Messages
-- During processing, the developer will send you messages.
-- You MUST respond immediately via message_notify_dev, and be brief. You should use it in your next thoughts/actions.
-
-
-<agent_end_task_rules>
-This tool is mandatory.
-You must use it to inform developer {username} that the task has been completed and that there are no further pending actions, in accordance with the objectives defined for the task.
-</agent_end_task_rules>
-
-### QUALITY STANDARDS 
-- Document every major decision in Notion(
-  ##Important: When writing to Notion, you must strictly follow its content structure, including the correct use of headings (heading_1, heading_2, etc.) and other formatting standards. No deviations are allowed.
-  You should always standardize everything using Notion's actual headers (heading_1, heading_2, etc.), making the structure
-  semantically better for reading and navigation.
-  )
-- Communicate transparently at each step 
-- Write clean, well-documented code 
-- Follow existing project conventions 
-- Test implementations when possible 
-- Ensure security and performance 
-
-<scope_and_limitations>
-# WHAT YOU DON'T HANDLE 
-- Non-technical questions 
-- Personal advice 
-- General conversation 
-- Tasks outside software development 
-
-# IF ASKED NON-TECHNICAL QUESTIONS 
-- Use message_notify_dev to politely decline 
-- Explain you only handle technical/coding tasks 
-- Suggest they ask a development-related question instead 
-</scope_and_limitations>
+---
 
+### SCOPE & LIMITATIONS
+
+**1. IN-SCOPE TASKS:**
+- Software architecture and design.
+- Code generation, analysis, and debugging.
+- Using provided tools to complete development objectives.
+- Creating technical documentation and diagrams.
+
+**2. OUT-OF-SCOPE TASKS:**
+You MUST professionally decline to engage with any of the following:
+- Non-technical questions (e.g., weather, news, general facts).
+- Personal, financial, or legal advice.
+- General conversation, opinions, or jokes.
+- Any task not directly related to software development.
+
+**3. PROTOCOL FOR OUT-OF-SCOPE REQUESTS:**
+If a user asks for something that is out-of-scope, follow this exact procedure:
+1.  Do NOT attempt to answer the question.
+2.  Use the \`message_notify_user\` tool.
+3.  Use the \`agent_end_task\` tool.
 `;
 function getUnifiedSystemPrompt() {
   const now = /* @__PURE__ */ new Date();
@@ -1779,7 +1768,7 @@ function createApiContextWindow(fullHistory, maxTurns) {
   const turns = [];
   let currentTurn = [];
   let turnsFound = 0;
-  const isDevOverlay = (m) => m?.role === "user" && m?.name === "dev_overlay";
+  const isDevOverlay = (m) => m?.role === "user" && m?.name === "user_overlay";
   for (let i = conversationHistory.length - 1; i >= 0; i--) {
     const msg = conversationHistory[i];
     currentTurn.unshift(msg);
@@ -1834,16 +1823,16 @@ var BluMaAgent = class {
       this.isInterrupted = true;
       this.eventBus.emit("backend_message", { type: "done", status: "interrupted" });
     });
-    this.eventBus.on("dev_overlay", async (data) => {
+    this.eventBus.on("user_overlay", async (data) => {
       const clean = String(data.payload ?? "").trim();
-      this.history.push({ role: "user", name: "dev_overlay", content: clean });
-      this.eventBus.emit("backend_message", { type: "dev_overlay", payload: clean, ts: data.ts || Date.now() });
+      this.history.push({ role: "user", name: "user_overlay", content: clean });
+      this.eventBus.emit("backend_message", { type: "user_overlay", payload: clean, ts: data.ts || Date.now() });
       try {
         if (this.sessionFile) {
           await saveSessionHistory(this.sessionFile, this.history);
         }
       } catch (e) {
-        this.eventBus.emit("backend_message", { type: "error", message: `Falha ao salvar hist\xF3rico ap\xF3s dev_overlay: ${e.message}` });
+        this.eventBus.emit("backend_message", { type: "error", message: `Falha ao salvar hist\xF3rico ap\xF3s user_overlay: ${e.message}` });
       }
     });
   }
@@ -1934,7 +1923,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path7.basename(toolArgs.file_path);
+      const filename = path8.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}`;
@@ -1943,16 +1932,20 @@ ${editData.error.display}`;
   async _continueConversation() {
     try {
       if (this.isInterrupted) {
-        this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+        this.eventBus.emit("backend_message", { type: "info", message: "Task Canceled." });
         return;
       }
       const contextWindow = createApiContextWindow(this.history, this.maxContextTurns);
       const response = await this.llm.chatCompletion({
         model: this.deploymentName,
         messages: contextWindow,
+        temperature: 0.2,
         tools: this.mcpClient.getAvailableTools(),
         tool_choice: "required",
-        parallel_tool_calls: false
+        reasoning_effort: "high",
+        parallel_tool_calls: false,
+        max_tokens: 512
+        // Limite de tokens para evitar respostas muito longas
       });
       if (this.isInterrupted) {
         this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
@@ -1961,7 +1954,7 @@ ${editData.error.display}`;
       const message = response.choices[0].message;
       this.history.push(message);
       if (message.tool_calls) {
-        const autoApprovedTools = ["agent_end_task", "message_notify_dev", "reasoning_nootebook"];
+        const autoApprovedTools = ["agent_end_task", "message_notify_user", "reasoning_nootebook"];
         const toolToCall = message.tool_calls[0];
         const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
         if (isSafeTool) {
@@ -2042,11 +2035,11 @@ You extend the BluMa multi-agent architecture and handle the project bootstrappi
   You are BluMa InitSubAgent. Maintain professionalism and technical language.
 
 - Communication:
-  ALL messages must be sent via 'message_notify_dev'.
-  No direct text replies to the developer.
+  ALL messages must be sent via 'message_notify_user'.
+  No direct text replies to the user.
 
 - Task Completion:
-  When the init task is completed, immediately invoke 'agent_end_task' without dev permissions.
+  When the init task is completed, immediately invoke 'agent_end_task' without user permissions.
 
 - Tool Rules:
   Never make parallel tool calls.
@@ -2068,20 +2061,20 @@ You extend the BluMa multi-agent architecture and handle the project bootstrappi
 - Architecture: {architecture}
 - Current Working Directory: {workdir}
 - Shell: {shell_type}
-- Username: {username}
+- User: {username}
 - Current Date: {current_date}
 - Timezone: {timezone}
 - Locale: {locale}
 </current_system_environment>
 
 <message_rules>
-- Communicate with dev's via message tools instead of direct text responses
+- Communicate with user's via message tools instead of direct text responses
 - Reply immediately to new user messages before other operations
 - First reply must be brief, only confirming receipt without specific solutions
-- Notify dev's with brief explanation when changing methods or strategies
+- Notify user's with brief explanation when changing methods or strategies
 - Message tools are divided into notify (non-blocking, no reply needed) and ask (blocking)
 - Actively use notify for progress updates, reserve ask for essential needs to avoid blocking
-- Must message dev's with results and deliverables before upon task completion 'agent_end_task'
+- Must message user's with results and deliverables before upon task completion 'agent_end_task'
 </message_rules>
 
 <reasoning_rules>
@@ -2091,7 +2084,7 @@ CRITICAL: Your laptop (reasoning_nootebook) is your ORGANIZED MIND
 ## NEVER PUT CHECKLISTS OR STEPS IN THE THOUGHT TEXT
 ## ALWAYS USE A NOTEBOOK (Always for):
 - ANY task
-- Before starting development (plan first!)
+- Before starting userelopment (plan first!)
 - Projects with multiple files (organize the structure)
 - Debugging sessions (monitor discoveries)
 - Extensive refactoring (map the changes)
@@ -2140,7 +2133,7 @@ Do not include future steps/to-dos in thought; put them strictly in remaining_ta
 
 <agent_end_task_rules>
   This tool is mandatory.
-  You must use it to inform developer {username} that the task has been completed and that there are no further pending actions, in accordance with the objectives defined for the task.
+  You must use it to inform usereloper {username} that the task has been completed and that there are no further pending actions, in accordance with the objectives defined for the task.
 </agent_end_task_rules>
 
 ### Tool Naming Policy
@@ -2167,9 +2160,9 @@ Rule Summary:
 - Never invent file content. Read files via tools to confirm.
 
 ## OUTPUT & PROTOCOLS
-- Emit 'backend_message' events through tools only (message_notify_dev) for progress updates.
-- Before writing BluMa.md, propose structure via message_notify_dev and proceed using edit_tool.
-- If an irreversible operation is needed (e.g., overwriting an existing BluMa.md), issue 'confirmation_request' unless dev policy indicates auto-approval.
+- Emit 'backend_message' events through tools only (message_notify_user) for progress updates.
+- Before writing BluMa.md, propose structure via message_notify_user and proceed using edit_tool.
+- If an irreversible operation is needed (e.g., overwriting an existing BluMa.md), issue 'confirmation_request' unless user policy indicates auto-approval.
 - Never send or present draft versions of BluMa.md. Only produce and deliver the final, validated BluMa.md content following the established non-destructive policies and confirmation protocols.
 - On successful generation of BluMa.md, emit 'done' with status 'completed' and call agent_end_task.
 
@@ -2182,7 +2175,7 @@ Rule Summary:
 ## EXEMPLAR FLOW (GUIDELINE)
 1) Explore repo: ls + targeted readLines for key files (package.json, tsconfig.json, README, etc.)
 2) Synthesize stack and structure with citations of evidence (file paths) in the notebook
-3) Draft BluMa.md structure (message_notify_dev)
+3) Draft BluMa.md structure (message_notify_user)
 4) Write BluMa.md via edit_tool
 5) Announce completion and agent_end_task
 
@@ -2272,7 +2265,7 @@ ${editData.error.display}`;
   async _continueConversation() {
     try {
       if (this.isInterrupted) {
-        this.emitEvent("info", { message: "SubAgent task cancelled by user." });
+        this.emitEvent("info", { message: "SubAgent task cancelled byuserr." });
         return;
       }
       const contextWindow = this.history.slice(-this.maxContextTurns);
@@ -2284,7 +2277,7 @@ ${editData.error.display}`;
         parallel_tool_calls: false
       });
       if (this.isInterrupted) {
-        this.emitEvent("info", { message: "SubAgent task cancelled by user." });
+        this.emitEvent("info", { message: "SubAgent task cancelled byuserr." });
         return;
       }
       const message = response.choices[0].message;
@@ -2333,7 +2326,7 @@ ${editData.error.display}`;
       try {
         if (this.isInterrupted) {
           this.emitEvent("info", { message: "SubAgent task cancelled before tool execution." });
-          toolResultContent = JSON.stringify({ error: "Task cancelled by user before execution." });
+          toolResultContent = JSON.stringify({ error: "Task cancelled byuserr before execution." });
         } else {
           const result = await this.ctx.mcpClient.invoke(toolName, toolArgs);
           let finalResult = result;
@@ -2449,7 +2442,7 @@ var SubAgentsBluMa = class {
 };
 
 // src/app/agent/agent.ts
-var globalEnvPath = path8.join(os6.homedir(), ".bluma-cli", ".env");
+var globalEnvPath = path9.join(os6.homedir(), ".bluma-cli", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -2579,19 +2572,19 @@ var Agent = class {
 };
 
 // src/app/ui/WorkingTimer.tsx
-import { useState as useState3, useEffect as useEffect2 } from "react";
+import { useState as useState4, useEffect as useEffect3 } from "react";
 import { Box as Box7, Text as Text7 } from "ink";
 import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 var WorkingTimer = () => {
-  const [seconds, setSeconds] = useState3(0);
-  const [dotIndex, setDotIndex] = useState3(1);
-  useEffect2(() => {
+  const [seconds, setSeconds] = useState4(0);
+  const [dotIndex, setDotIndex] = useState4(1);
+  useEffect3(() => {
     const secondsTimer = setInterval(() => {
       setSeconds((prev) => prev + 1);
     }, 1e3);
     return () => clearInterval(secondsTimer);
   }, []);
-  useEffect2(() => {
+  useEffect3(() => {
     const dotsTimer = setInterval(() => {
       setDotIndex((prev) => prev % 3 + 1);
     }, 100);
@@ -2610,7 +2603,7 @@ import { Box as Box9 } from "ink";
 
 // src/app/ui/components/toolCallRenderers.tsx
 import { Box as Box8, Text as Text8 } from "ink";
-import path9 from "path";
+import path10 from "path";
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 var formatArgumentsForDisplay = (args) => {
   if (typeof args === "string") {
@@ -2622,7 +2615,9 @@ var formatArgumentsForDisplay = (args) => {
   }
   return JSON.stringify(args, null, 2);
 };
-var renderShellCommand2 = ({ args }) => {
+var renderShellCommand2 = ({
+  args
+}) => {
   const command = args.command || "[command not found]";
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
@@ -2643,7 +2638,7 @@ var renderLsTool2 = ({ args }) => {
   } catch (e) {
     directoryPath = "Error parsing arguments";
   }
-  const finalDirectoryName = path9.basename(directoryPath);
+  const finalDirectoryName = path10.basename(directoryPath);
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
       /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
@@ -2655,7 +2650,9 @@ var renderLsTool2 = ({ args }) => {
     ] }) })
   ] });
 };
-var renderCountFilesLines = ({ args }) => {
+var renderCountFilesLines = ({
+  args
+}) => {
   let directoryPath = "[path not found]";
   try {
     const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
@@ -2663,7 +2660,7 @@ var renderCountFilesLines = ({ args }) => {
   } catch (e) {
     directoryPath = "Error parsing arguments";
   }
-  const finalDirectoryName = path9.basename(directoryPath);
+  const finalDirectoryName = path10.basename(directoryPath);
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
       /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
@@ -2675,7 +2672,9 @@ var renderCountFilesLines = ({ args }) => {
     ] }) })
   ] });
 };
-var renderReadFileLines2 = ({ args }) => {
+var renderReadFileLines2 = ({
+  args
+}) => {
   let filepath = "[path not found]";
   let startLine = 0;
   let endLine = 0;
@@ -2687,7 +2686,7 @@ var renderReadFileLines2 = ({ args }) => {
   } catch (e) {
     filepath = "Error parsing arguments";
   }
-  const finalFileName = path9.basename(filepath);
+  const finalFileName = path10.basename(filepath);
   return (
     // A caixa externa com a borda, seguindo o template
     /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
@@ -2711,7 +2710,9 @@ var renderReadFileLines2 = ({ args }) => {
     ] })
   );
 };
-var renderBlumaNotebook = ({ args }) => {
+var renderBlumaNotebook = ({
+  args
+}) => {
   try {
     let dataToParse = args;
     if (args && typeof args === "object") {
@@ -2724,16 +2725,30 @@ var renderBlumaNotebook = ({ args }) => {
     }
     return (
       // Usamos a mesma estrutura de caixa com borda
-      /* @__PURE__ */ jsxs8(Box8, { borderStyle: "round", borderColor: "green", flexDirection: "column", paddingX: 1, children: [
-        /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Thought:" }),
-          /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: thinkingData.thought }) })
-        ] }),
-        thinkingData.remaining_tasks && thinkingData.remaining_tasks.length > 0 && /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
-          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Remaining Tasks:" }),
-          thinkingData.remaining_tasks.map((task, index) => /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { children: /* @__PURE__ */ jsx8(Text8, { color: task.startsWith("\u{1F5F8}") ? "green" : "yellow", children: task }) }) }, index))
-        ] })
-      ] })
+      /* @__PURE__ */ jsxs8(
+        Box8,
+        {
+          flexDirection: "column",
+          paddingX: 1,
+          children: [
+            /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Thought:" }),
+              /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { color: "gray", children: thinkingData.thought }) })
+            ] }),
+            thinkingData.remaining_tasks && thinkingData.remaining_tasks.length > 0 && /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Remaining Tasks:" }),
+              thinkingData.remaining_tasks.map((task, index) => /* @__PURE__ */ jsx8(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { children: /* @__PURE__ */ jsx8(
+                Text8,
+                {
+                  color: task.startsWith("\u{1F5F9}") ? "green" : "yellow",
+                  strikethrough: task.startsWith("\u{1F5F9}"),
+                  children: task
+                }
+              ) }) }, index))
+            ] })
+          ]
+        }
+      )
     );
   } catch (e) {
     return /* @__PURE__ */ jsxs8(Box8, { borderStyle: "round", borderColor: "blue", paddingX: 1, children: [
@@ -2742,7 +2757,10 @@ var renderBlumaNotebook = ({ args }) => {
     ] });
   }
 };
-var renderEditToolCall = ({ args, preview }) => {
+var renderEditToolCall = ({
+  args,
+  preview
+}) => {
   let filepath = "[path not specified]";
   try {
     const parsedArgs = typeof args === "string" ? JSON.parse(args) : args;
@@ -2750,7 +2768,7 @@ var renderEditToolCall = ({ args, preview }) => {
   } catch (e) {
     filepath = "Error parsing arguments";
   }
-  const finalFileName = path9.basename(filepath);
+  const finalFileName = path10.basename(filepath);
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
       /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u25CF " }),
@@ -2763,7 +2781,10 @@ var renderEditToolCall = ({ args, preview }) => {
     preview && /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(SimpleDiff, { text: preview, maxHeight: Infinity }) })
   ] });
 };
-var renderGenericToolCall = ({ toolName, args }) => {
+var renderGenericToolCall = ({
+  toolName,
+  args
+}) => {
   const formattedArgs = formatArgumentsForDisplay(args);
   return (
     // A "moldura" padrão de sucesso com a borda cinza
@@ -2780,18 +2801,18 @@ var renderGenericToolCall = ({ toolName, args }) => {
   );
 };
 var ToolRenderDisplay = {
-  "shell_command": renderShellCommand2,
-  "ls_tool": renderLsTool2,
-  "reasoning_nootebook": renderBlumaNotebook,
-  "count_file_lines": renderCountFilesLines,
-  "read_file_lines": renderReadFileLines2,
-  "edit_tool": renderEditToolCall
+  shell_command: renderShellCommand2,
+  ls_tool: renderLsTool2,
+  reasoning_nootebook: renderBlumaNotebook,
+  count_file_lines: renderCountFilesLines,
+  read_file_lines: renderReadFileLines2,
+  edit_tool: renderEditToolCall
 };
 
 // src/app/ui/components/ToolCallDisplay.tsx
 import { jsx as jsx9 } from "react/jsx-runtime";
 var ToolCallDisplayComponent = ({ toolName, args, preview }) => {
-  if (toolName.includes("message_notify_dev") || toolName.includes("agent_end_task")) {
+  if (toolName.includes("message_notify_user") || toolName.includes("agent_end_task")) {
     return null;
   }
   const Renderer = ToolRenderDisplay[toolName] || renderGenericToolCall;
@@ -2804,7 +2825,7 @@ import { memo as memo3 } from "react";
 import { Box as Box10, Text as Text9 } from "ink";
 import { jsx as jsx10 } from "react/jsx-runtime";
 var ToolResultDisplayComponent = ({ toolName, result }) => {
-  if (!toolName.includes("message_notify_dev")) {
+  if (!toolName.includes("message_notify_user")) {
     return null;
   }
   try {
@@ -3028,21 +3049,21 @@ var SlashCommands_default = SlashCommands;
 import updateNotifier from "update-notifier";
 import { readPackageUp } from "read-package-up";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import path10 from "path";
-import fs8 from "fs";
+import path11 from "path";
+import fs9 from "fs";
 function findPackageJsonNearest(startDir) {
   let dir = startDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = path10.join(dir, "package.json");
-    if (fs8.existsSync(candidate)) {
+    const candidate = path11.join(dir, "package.json");
+    if (fs9.existsSync(candidate)) {
       try {
-        const raw = fs8.readFileSync(candidate, "utf8");
+        const raw = fs9.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name && parsed?.version) return parsed;
       } catch {
       }
     }
-    const parent = path10.dirname(dir);
+    const parent = path11.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3055,15 +3076,15 @@ async function checkForUpdates() {
     }
     const binPath = process.argv?.[1];
     let pkg;
-    if (binPath && fs8.existsSync(binPath)) {
-      const candidatePkg = findPackageJsonNearest(path10.dirname(binPath));
+    if (binPath && fs9.existsSync(binPath)) {
+      const candidatePkg = findPackageJsonNearest(path11.dirname(binPath));
       if (candidatePkg?.name && candidatePkg?.version) {
         pkg = candidatePkg;
       }
     }
     if (!pkg) {
       const __filename = fileURLToPath3(import.meta.url);
-      const __dirname = path10.dirname(__filename);
+      const __dirname = path11.dirname(__filename);
       const result = await readPackageUp({ cwd: __dirname });
       pkg = result?.packageJson;
     }
@@ -3149,26 +3170,26 @@ var ErrorMessage_default = ErrorMessage;
 // src/app/ui/App.tsx
 import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
 var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
-  const agentInstance = useRef(null);
-  const [history, setHistory] = useState4([]);
-  const [statusMessage, setStatusMessage] = useState4(
+  const agentInstance = useRef2(null);
+  const [history, setHistory] = useState5([]);
+  const [statusMessage, setStatusMessage] = useState5(
     "Initializing agent..."
   );
-  const [toolsCount, setToolsCount] = useState4(null);
-  const [mcpStatus, setMcpStatus] = useState4(
+  const [toolsCount, setToolsCount] = useState5(null);
+  const [mcpStatus, setMcpStatus] = useState5(
     "connecting"
   );
-  const [isProcessing, setIsProcessing] = useState4(true);
-  const [pendingConfirmation, setPendingConfirmation] = useState4(
+  const [isProcessing, setIsProcessing] = useState5(true);
+  const [pendingConfirmation, setPendingConfirmation] = useState5(
     null
   );
-  const [confirmationPreview, setConfirmationPreview] = useState4(
+  const [confirmationPreview, setConfirmationPreview] = useState5(
     null
   );
-  const [isInitAgentActive, setIsInitAgentActive] = useState4(false);
-  const alwaysAcceptList = useRef([]);
+  const [isInitAgentActive, setIsInitAgentActive] = useState5(false);
+  const alwaysAcceptList = useRef2([]);
   const workdir = process.cwd();
-  const updateCheckRan = useRef(false);
+  const updateCheckRan = useRef2(false);
   const handleInterrupt = useCallback(() => {
     if (!isProcessing) return;
     eventBus2.emit("user_interrupt");
@@ -3192,8 +3213,11 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
         }
         if (cmd === "init") {
           setIsInitAgentActive(true);
+          setIsProcessing(true);
+        } else {
+          setIsProcessing(false);
+          setIsInitAgentActive(false);
         }
-        setIsProcessing(true);
         setHistory((prev) => [
           ...prev,
           {
@@ -3257,7 +3281,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
     },
     []
   );
-  useEffect3(() => {
+  useEffect4(() => {
     setHistory([{ id: 0, component: /* @__PURE__ */ jsx15(Header, {}) }]);
     const initializeAgent = async () => {
       try {
@@ -3391,7 +3415,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
               result: parsed.result
             }
           );
-        } else if (parsed.type === "dev_overlay") {
+        } else if (parsed.type === "user_overlay") {
           newComponent = /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsxs13(Text14, { color: "gray", children: [
             /* @__PURE__ */ jsxs13(Text14, { color: "blue", children: [
               ">",
@@ -3418,13 +3442,13 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
       }
     };
     const handleUiOverlay = (data) => {
-      eventBus2.emit("dev_overlay", data);
+      eventBus2.emit("user_overlay", data);
     };
-    uiEventBus.on("dev_overlay", handleUiOverlay);
+    uiEventBus.on("user_overlay", handleUiOverlay);
     eventBus2.on("backend_message", handleBackendMessage);
     initializeAgent();
     return () => {
-      uiEventBus.off("dev_overlay", handleUiOverlay);
+      uiEventBus.off("user_overlay", handleUiOverlay);
       eventBus2.off("backend_message", handleBackendMessage);
     };
   }, [eventBus2, sessionId2, handleConfirmation]);