@nomad-e/bluma-cli 0.0.26 → 0.0.28

package/dist/main.js

@@ -36,7 +36,8 @@ var Header = () => {
       /* @__PURE__ */ jsxs(Text, { children: [
         "3. Run ",
         /* @__PURE__ */ jsx(Text, { color: "cyan", children: "/init" }),
-        " to create a ",
+        " to create a",
+        " ",
         /* @__PURE__ */ jsx(Text, { color: "cyan", children: "BluMa.md" }),
         ", file with instructions for BluMa."
       ] }),
@@ -57,36 +58,42 @@ var SessionInfo = ({
   // Número de ferramentas ativas carregadas pelo MCP
   mcpStatus
   // Estado da conexão central MCP (connecting/connected)
-}) => /* @__PURE__ */ jsxs(
+}) => /* @__PURE__ */ jsx(
   Box,
   {
     borderStyle: "round",
     borderColor: "gray",
-    padding: 1,
     flexDirection: "column",
     marginBottom: 1,
-    children: [
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: "localhost" }),
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: " session:" }),
-        " ",
-        /* @__PURE__ */ jsx(Text, { color: "magenta", children: sessionId2 })
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
-        " ",
-        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-          "workdir: ",
-          workdir
-        ] })
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
-        " ",
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: "mcp: " }),
-        /* @__PURE__ */ jsx(Text, { color: mcpStatus === "connected" ? "green" : "yellow", children: mcpStatus })
-      ] })
-    ]
+    children: /* @__PURE__ */ jsxs(
+      Box,
+      {
+        marginLeft: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: "localhost" }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: " session:" }),
+            " ",
+            /* @__PURE__ */ jsx(Text, { color: "magenta", children: sessionId2 })
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
+            " ",
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              "workdir: ",
+              workdir
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: "magenta", children: "\u21B3" }),
+            " ",
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: "mcp: " }),
+            /* @__PURE__ */ jsx(Text, { color: mcpStatus === "connected" ? "green" : "yellow", children: mcpStatus })
+          ] })
+        ]
+      }
+    )
   }
 );
 
@@ -239,7 +246,7 @@ var filterSlashCommands = (query) => {
 import { 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 }) => {
+var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt, disableWhileProcessing = false }) => {
   const { stdout } = useStdout();
   const [viewWidth, setViewWidth] = useState(() => stdout.columns - 6);
   useEffect(() => {
@@ -261,10 +268,14 @@ var InputPrompt = ({ onSubmit, isReadOnly, onInterrupt }) => {
     }
     onSubmit(value);
   };
+  const effectiveReadOnly = disableWhileProcessing ? false : isReadOnly;
   const { text, cursorPosition, viewStart } = useCustomInput({
-    onSubmit: permissiveOnSubmit,
+    onSubmit: (value) => {
+      if (disableWhileProcessing && isReadOnly) return;
+      permissiveOnSubmit(value);
+    },
     viewWidth,
-    isReadOnly,
+    isReadOnly: effectiveReadOnly,
     onInterrupt
   });
   const [slashOpen, setSlashOpen] = useState(false);
@@ -431,10 +442,7 @@ var SimpleDiff = ({ text, maxHeight }) => {
       } else if (line.startsWith("@@")) {
         color = "cyan";
       }
-      return /* @__PURE__ */ jsxs4(Text4, { color, children: [
-        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  \u21B3 " }),
-        line === "" ? " " : line
-      ] }, index);
+      return /* @__PURE__ */ jsx4(Text4, { color, children: line === "" ? " " : line }, index);
     })
   ] });
 };
@@ -610,192 +618,838 @@ var ConfirmationPrompt = ({ toolCalls, preview, onDecision }) => {
 // src/app/agent/agent.ts
 import OpenAI from "openai";
 import * as dotenv from "dotenv";
-import path7 from "path";
-import os5 from "os";
+import path8 from "path";
+import os6 from "os";
 
-// src/app/agent/session_manger/session_manager.ts
-import path2 from "path";
+// src/app/agent/tool_invoker.ts
+import { promises as fs5 } from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+
+// src/app/agent/tools/natives/shell_command.ts
 import os from "os";
-import { promises as fs } from "fs";
-var fileLocks = /* @__PURE__ */ new Map();
-async function withFileLock(file, fn) {
-  const prev = fileLocks.get(file) || Promise.resolve();
-  let release;
-  const p = new Promise((res) => release = res);
-  fileLocks.set(file, prev.then(() => p));
-  try {
-    const result = await fn();
-    return result;
-  } finally {
-    release();
-    if (fileLocks.get(file) === p) fileLocks.delete(file);
-  }
-}
-function expandHome(p) {
-  if (!p) return p;
-  if (p.startsWith("~")) {
-    return path2.join(os.homedir(), p.slice(1));
-  }
-  return p;
+import { exec } from "child_process";
+function shellCommand(args) {
+  const { command, timeout = 20, cwd = process.cwd(), verbose = false } = args;
+  return new Promise((resolve) => {
+    const report = {
+      platform: os.platform(),
+      // Coleta o sistema operacional (ex: 'win32', 'linux')
+      command,
+      cwd,
+      results: []
+    };
+    if (verbose) {
+      report.env = {
+        PATH: process.env.PATH || "NOT SET",
+        ComSpec: process.env.ComSpec || "NOT SET"
+        // Específico do Windows, útil para saber qual cmd está sendo usado
+      };
+    }
+    const childProcess = exec(
+      command,
+      {
+        // O diretório de trabalho para o comando.
+        cwd,
+        // O timeout em milissegundos. Se o comando exceder este tempo, ele será encerrado.
+        timeout: timeout * 1e3,
+        // A opção `shell` foi removida, pois `exec` usa o shell por padrão.
+        // Especificar a codificação garante que a saída seja tratada como texto UTF-8.
+        encoding: "utf-8"
+      },
+      // Este é o callback que será executado QUANDO o processo filho terminar,
+      // seja por sucesso, erro ou timeout.
+      (error, stdout, stderr) => {
+        const result = {
+          method: "child_process.exec",
+          status: "Success",
+          // Se `error` existir, ele contém o código de saída. Caso contrário, o código é 0 (sucesso).
+          code: error ? error.code || null : 0,
+          // Limpa espaços em branco do início e fim das saídas.
+          output: stdout.trim(),
+          error: stderr.trim()
+        };
+        if (error) {
+          if (error.killed) {
+            result.status = "Timeout";
+            result.error = `Command exceeded timeout of ${timeout} seconds. ${stderr.trim()}`.trim();
+          } else {
+            result.status = "Error";
+            result.error = `${error.message}
+${stderr.trim()}`.trim();
+          }
+        }
+        if (verbose) {
+          report.results.push(result);
+          resolve(JSON.stringify(report, null, 2));
+        } else {
+          resolve(JSON.stringify(result, null, 2));
+        }
+      }
+    );
+  });
 }
-function getPreferredAppDir() {
-  const fixed = path2.join(os.homedir(), ".bluma-cli");
-  return path2.resolve(expandHome(fixed));
+
+// src/app/agent/tools/natives/edit.ts
+import path2 from "path";
+import { promises as fs } 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, "\\");
 }
-async function safeRenameWithRetry(src, dest, maxRetries = 6) {
-  let attempt = 0;
-  let lastErr;
-  const isWin = process.platform === "win32";
-  while (attempt <= maxRetries) {
-    try {
-      await fs.rename(src, dest);
-      return;
-    } catch (e) {
-      lastErr = e;
-      const code = e && e.code || "";
-      const transient = code === "EPERM" || code === "EBUSY" || code === "ENOTEMPTY" || code === "EACCES";
-      if (!(isWin && transient) || attempt === maxRetries) break;
-      const backoff = Math.min(1e3, 50 * Math.pow(2, attempt));
-      await new Promise((r) => setTimeout(r, backoff));
-      attempt++;
+function ensureCorrectEdit(currentContent, oldString, newString, expectedReplacements) {
+  let finalOldString = oldString;
+  let finalNewString = newString;
+  let occurrences = currentContent.split(finalOldString).length - 1;
+  if (occurrences !== expectedReplacements && occurrences === 0) {
+    const unescapedOldString = unescapeLlmString(oldString);
+    const unescapedOccurrences = currentContent.split(unescapedOldString).length - 1;
+    if (unescapedOccurrences > 0) {
+      finalOldString = unescapedOldString;
+      finalNewString = unescapeLlmString(newString);
+      occurrences = unescapedOccurrences;
+    } else {
+      const trimmedOldString = oldString.trim();
+      const trimmedOccurrences = currentContent.split(trimmedOldString).length - 1;
+      if (trimmedOccurrences > 0) {
+        finalOldString = trimmedOldString;
+        finalNewString = newString.trim();
+        occurrences = trimmedOccurrences;
+      }
     }
   }
-  try {
-    const data = await fs.readFile(src);
-    await fs.writeFile(dest, data);
-    await fs.unlink(src).catch(() => {
-    });
-    return;
-  } catch (fallbackErr) {
-    throw lastErr || fallbackErr;
-  }
-}
-async function ensureSessionDir() {
-  const appDir = getPreferredAppDir();
-  const sessionDir = path2.join(appDir, "sessions");
-  await fs.mkdir(sessionDir, { recursive: true });
-  return sessionDir;
+  return [finalOldString, finalNewString, occurrences];
 }
-async function loadOrcreateSession(sessionId2) {
-  const sessionDir = await ensureSessionDir();
-  const sessionFile = path2.join(sessionDir, `${sessionId2}.json`);
+async function calculateEdit(filePath, oldString, newString, expectedReplacements) {
+  let currentContent = null;
+  let isNewFile = false;
+  let error = null;
+  let finalNewString = unescapeLlmString(newString).replace(/\r\n/g, "\n");
+  let finalOldString = oldString.replace(/\r\n/g, "\n");
+  let occurrences = 0;
   try {
-    await fs.access(sessionFile);
-    const fileContent = await fs.readFile(sessionFile, "utf-8");
-    const sessionData = JSON.parse(fileContent);
-    return [sessionFile, sessionData.conversation_history || []];
-  } catch (error) {
-    const newSessionData = {
-      session_id: sessionId2,
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      conversation_history: []
-    };
-    await fs.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
-    return [sessionFile, []];
+    currentContent = await fs.readFile(filePath, "utf-8");
+    currentContent = currentContent.replace(/\r\n/g, "\n");
+  } catch (e) {
+    if (e.code !== "ENOENT") {
+      error = { display: `Error reading file: ${e.message}`, raw: `Error reading file ${filePath}: ${e.message}` };
+      return { currentContent, newContent: "", occurrences: 0, error, isNewFile };
+    }
   }
-}
-async function saveSessionHistory(sessionFile, history) {
-  await withFileLock(sessionFile, async () => {
-    let sessionData;
-    try {
-      const dir = path2.dirname(sessionFile);
-      await fs.mkdir(dir, { recursive: true });
-    } catch {
+  if (currentContent === null) {
+    if (oldString === "") {
+      isNewFile = true;
+      occurrences = 1;
+    } else {
+      error = { display: "File not found. Cannot apply edit. Use an empty old_string to create a new file.", raw: `File not found: ${filePath}` };
     }
-    try {
-      const fileContent = await fs.readFile(sessionFile, "utf-8");
-      sessionData = JSON.parse(fileContent);
-    } catch (error) {
-      const code = error && error.code;
-      if (code !== "ENOENT") {
-        if (error instanceof Error) {
-          console.warn(`Could not read or parse session file ${sessionFile}. Re-initializing. Error: ${error.message}`);
-        } else {
-          console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
-        }
-      }
-      const sessionId2 = path2.basename(sessionFile, ".json");
-      sessionData = {
-        session_id: sessionId2,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        conversation_history: []
-      };
-      try {
-        await fs.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
-      } catch {
+  } else {
+    if (oldString === "") {
+      error = { display: "Failed to edit. Attempted to create a file that already exists.", raw: `File already exists, cannot create: ${filePath}` };
+    } else {
+      [finalOldString, finalNewString, occurrences] = ensureCorrectEdit(currentContent, finalOldString, finalNewString, expectedReplacements);
+      if (occurrences === 0) {
+        error = { display: "Failed to edit, could not find the string to replace.", raw: `0 occurrences found for old_string in ${filePath}. Check whitespace, indentation, and context.` };
+      } else if (occurrences !== expectedReplacements) {
+        error = { display: `Failed to edit, expected ${expectedReplacements} occurrence(s) but found ${occurrences}.`, raw: `Expected ${expectedReplacements} but found ${occurrences} for old_string in ${filePath}` };
       }
     }
-    sessionData.conversation_history = history;
-    sessionData.last_updated = (/* @__PURE__ */ new Date()).toISOString();
-    const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
-    try {
-      await fs.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
-      await safeRenameWithRetry(tempSessionFile, sessionFile);
-    } catch (writeError) {
-      if (writeError instanceof Error) {
-        console.error(`Fatal error saving session to ${sessionFile}: ${writeError.message}`);
-      } else {
-        console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
-      }
-      try {
-        await fs.unlink(tempSessionFile);
-      } catch {
-      }
+  }
+  let newContentResult = "";
+  if (!error) {
+    if (isNewFile) {
+      newContentResult = finalNewString;
+    } else if (currentContent !== null) {
+      newContentResult = currentContent.replaceAll(finalOldString, finalNewString);
     }
-  });
+  }
+  return { currentContent, newContent: newContentResult, occurrences, error, isNewFile };
+}
+function createDiff(filename, oldContent, newContent) {
+  const diff = diffLines(oldContent, newContent, {
+    // `unified: 3` é o padrão para diffs, mostrando 3 linhas de contexto.
+    // `newlineIsToken: true` lida melhor com mudanças de quebra de linha.
+  });
+  let diffString = `--- a/${filename}
++++ b/${filename}
+`;
+  diff.forEach((part) => {
+    const prefix = part.added ? "+" : part.removed ? "-" : " ";
+    part.value.split("\n").slice(0, -1).forEach((line) => {
+      diffString += `${prefix}${line}
+`;
+    });
+  });
+  return diffString;
+}
+async function editTool(args) {
+  const { file_path, old_string, new_string, expected_replacements = 1 } = args;
+  if (!path2.isAbsolute(file_path)) {
+    return { success: false, error: `Invalid parameters: file_path must be absolute.`, file_path };
+  }
+  if (file_path.includes("..")) {
+    return { success: false, error: `Invalid parameters: file_path cannot contain '..'.`, file_path };
+  }
+  try {
+    const editData = await calculateEdit(file_path, old_string, new_string, expected_replacements);
+    if (editData.error) {
+      return {
+        success: false,
+        error: `Execution failed: ${editData.error.display}`,
+        details: editData.error.raw,
+        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);
+    if (editData.isNewFile) {
+      return {
+        success: true,
+        file_path,
+        description: `Created new file: ${relativePath}`,
+        message: `Created new file: ${file_path} with the provided content.`,
+        is_new_file: true,
+        occurrences: editData.occurrences,
+        relative_path: relativePath
+      };
+    } else {
+      const finalDiff = createDiff(filename, editData.currentContent || "", editData.newContent);
+      return {
+        success: true,
+        file_path,
+        description: `Modified ${relativePath} (${editData.occurrences} replacement(s)).`,
+        message: `Successfully modified file: ${file_path}. Diff of changes:
+${finalDiff}`,
+        is_new_file: false,
+        occurrences: editData.occurrences,
+        relative_path: relativePath
+      };
+    }
+  } catch (e) {
+    return {
+      success: false,
+      error: `An unexpected error occurred during the edit operation: ${e.message}`,
+      file_path
+    };
+  }
 }
 
-// src/app/agent/core/prompt/prompt_builder.ts
-import os2 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.
-
----
-
-## BEHAVIORAL RULES
-
-- **Identity:**  
-  You are BluMa (NomadEngenuity). Maintain professionalism and technical language.
-
-- **Communication:**  
-  ALL messages must be sent via 'message_notify_dev'.  
-  **No direct text replies to the developer.**
-
-- **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.
+// src/app/agent/tools/natives/message.ts
+import { v4 as uuidv4 } from "uuid";
+function messageNotifyDev(args) {
+  const { text_markdown } = args;
+  const notification = {
+    type: "message_notify_dev",
+    id: `notify_${uuidv4()}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    content: {
+      format: "markdown",
+      body: text_markdown
+    },
+    success: true,
+    delivered: true
+  };
+  return Promise.resolve(notification);
+}
 
-<current_system_environment>
-- Operating System: {os_type} ({os_version})
-- Architecture: {architecture}
-- Current Working Directory: {workdir}
-- Shell: {shell_type}
-- Username: {username}
-- Current Date: {current_date}
-- Timezone: {timezone}
-- Locale: {locale}
-</current_system_environment>
+// src/app/agent/tools/natives/ls.ts
+import { promises as fs2 } from "fs";
+import path3 from "path";
+var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
+  ".git",
+  ".gitignore",
+  ".venv",
+  "venv",
+  "node_modules",
+  "__pycache__",
+  "*.pyc",
+  ".vscode",
+  ".idea",
+  "dist",
+  "build",
+  "*.log",
+  ".DS_Store"
+]);
+async function ls(args) {
+  const {
+    directory_path = ".",
+    recursive = false,
+    ignore_patterns = [],
+    start_index = 0,
+    end_index,
+    show_hidden = false,
+    file_extensions,
+    max_depth
+  } = args;
+  try {
+    const basePath = path3.resolve(directory_path);
+    if (!(await fs2.stat(basePath)).isDirectory()) {
+      throw new Error(`Directory '${directory_path}' not found.`);
+    }
+    const allIgnorePatterns = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore_patterns]);
+    const normalizedExtensions = file_extensions?.map((ext) => ext.toLowerCase());
+    const allFiles = [];
+    const allDirs = [];
+    const walk = async (currentDir, currentDepth) => {
+      if (max_depth !== void 0 && currentDepth > max_depth) return;
+      const entries = await fs2.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 isHidden = entryName.startsWith(".");
+        if (allIgnorePatterns.has(entryName) || isHidden && !show_hidden) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          allDirs.push(posixPath);
+          if (recursive) {
+            await walk(fullPath, currentDepth + 1);
+          }
+        } else if (entry.isFile()) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path3.extname(entryName).toLowerCase())) {
+            allFiles.push(posixPath);
+          }
+        }
+      }
+    };
+    await walk(basePath, 0);
+    allFiles.sort();
+    allDirs.sort();
+    return {
+      success: true,
+      path: basePath.split(path3.sep).join("/"),
+      recursive,
+      total_files: allFiles.length,
+      total_directories: allDirs.length,
+      showing_files: `[${start_index}:${Math.min(end_index ?? allFiles.length, allFiles.length)}]`,
+      showing_directories: `[${start_index}:${Math.min(end_index ?? allDirs.length, allDirs.length)}]`,
+      files: allFiles.slice(start_index, end_index),
+      directories: allDirs.slice(start_index, end_index),
+      filters_applied: { ignore_patterns: [...allIgnorePatterns], show_hidden, file_extensions, max_depth }
+    };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
 
+// src/app/agent/tools/natives/readLines.ts
+import { promises as fs3 } from "fs";
+async function readLines(args) {
+  const { filepath, start_line, end_line } = args;
+  try {
+    if (!(await fs3.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 lines = fileContent.split("\n");
+    const total_lines = lines.length;
+    const startIndex = start_line - 1;
+    let endIndex = end_line;
+    if (startIndex >= total_lines) {
+      throw new Error(`start_line (${start_line}) exceeds file length (${total_lines} lines).`);
+    }
+    endIndex = Math.min(endIndex, total_lines);
+    const contentLines = lines.slice(startIndex, endIndex);
+    const content = contentLines.join("\n");
+    return {
+      success: true,
+      filepath,
+      content,
+      lines_read: contentLines.length,
+      start_line,
+      end_line: endIndex,
+      // Retorna o final real usado
+      total_file_lines: total_lines
+    };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
 
-<mermaid_diagrams>
-# MERMAID DIAGRAM CREATION - PERFECT SYNTAX REQUIRED!
-## CRITICAL: ALL DIAGRAMS MUST RENDER WITHOUT ERRORS
+// src/app/agent/tools/natives/count_lines.ts
+import { createReadStream } from "fs";
+import { promises as fs4 } from "fs";
+import readline from "readline";
+async function countLines(args) {
+  const { filepath } = args;
+  try {
+    if (!(await fs4.stat(filepath)).isFile()) {
+      throw new Error(`File '${filepath}' not found or is not a file.`);
+    }
+    const fileStream = createReadStream(filepath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    let lineCount = 0;
+    for await (const line of rl) {
+      lineCount++;
+    }
+    return { success: true, filepath, line_count: lineCount };
+  } catch (e) {
+    return { success: false, error: e.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 = path4.dirname(__filename);
+      const configPath = path4.resolve(__dirname, "config", "native_tools.json");
+      const fileContent = await fs5.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("message_notify_dev", messageNotifyDev);
+    this.toolImplementations.set("ls_tool", ls);
+    this.toolImplementations.set("count_file_lines", countLines);
+    this.toolImplementations.set("read_file_lines", readLines);
+    this.toolImplementations.set("agent_end_task", 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 fs6 } from "fs";
+import path5 from "path";
+import os2 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 = path5.dirname(__filename);
+    const defaultConfigPath = path5.resolve(__dirname, "config", "bluma-mcp.json");
+    const userConfigPath = path5.join(os2.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 fs6.readFile(configPath, "utf-8");
+      const processedContent = this.replaceEnvPlaceholders(fileContent);
+      return JSON.parse(processedContent);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (configType === "User") {
+        }
+      } else {
+        console.warn(`[MCPClient] Warning: Error reading ${configType} config file ${configPath}.`, error);
+      }
+      return {};
+    }
+  }
+  /**
+   * Conecta-se a um servidor MCP baseado em Stdio, adaptando o comando para o SO atual.
+   */
+  async connectToStdioServer(serverName, config2) {
+    let commandToExecute = config2.command;
+    let argsToExecute = config2.args || [];
+    const isWindows = os2.platform() === "win32";
+    if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
+      if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
+        commandToExecute = argsToExecute[1];
+        argsToExecute = argsToExecute.slice(2);
+      } else {
+        console.warn(`[MCPClient] Formato de comando 'cmd /c' inesperado para '${serverName}' em sistema n\xE3o-Windows. O servidor ser\xE1 ignorado.`);
+        return;
+      }
+    }
+    const transport = new StdioClientTransport({
+      command: commandToExecute,
+      // Usa o comando adaptado
+      args: argsToExecute,
+      // Usa os argumentos adaptados
+      env: config2.env
+    });
+    const mcp = new Client({ name: `bluma-cli-client-for-${serverName}`, version: "1.0.0" });
+    await mcp.connect(transport);
+    this.sessions.set(serverName, mcp);
+    const toolsResult = await mcp.listTools();
+    for (const tool of toolsResult.tools) {
+      const prefixedToolName = `${serverName}_${tool.name}`;
+      this.globalToolsForLlm.push({
+        type: "function",
+        function: {
+          name: prefixedToolName,
+          description: tool.description || "",
+          parameters: tool.inputSchema
+        }
+      });
+      this.toolToServerMap.set(prefixedToolName, {
+        server: serverName,
+        originalName: tool.name
+      });
+    }
+  }
+  async invoke(toolName, args) {
+    const route = this.toolToServerMap.get(toolName);
+    if (!route) {
+      return { error: `Ferramenta '${toolName}' n\xE3o encontrada ou registrada.` };
+    }
+    if (route.server === "native") {
+      return this.nativeToolInvoker.invoke(route.originalName, args);
+    } else {
+      const session = this.sessions.get(route.server);
+      if (!session) {
+        return { error: `Sess\xE3o para o servidor '${route.server}' n\xE3o encontrada.` };
+      }
+      const result = await session.callTool({ name: route.originalName, arguments: args });
+      return result.content;
+    }
+  }
+  getAvailableTools() {
+    return this.globalToolsForLlm;
+  }
+  // New: detailed list for UI with origin metadata
+  getAvailableToolsDetailed() {
+    const detailed = [];
+    for (const tool of this.globalToolsForLlm) {
+      const name = tool.function?.name;
+      if (!name) continue;
+      const route = this.toolToServerMap.get(name);
+      if (!route) continue;
+      const source = route.server === "native" ? "native" : "mcp";
+      detailed.push({ ...tool, source, server: route.server, originalName: route.originalName });
+    }
+    return detailed;
+  }
+  async close() {
+    for (const [name, session] of this.sessions.entries()) {
+      try {
+        await session.close();
+      } catch (error) {
+        console.error(`[MCPClient] Erro ao encerrar conex\xE3o com '${name}':`, error);
+      }
+    }
+  }
+  replaceEnvPlaceholders(content) {
+    return content.replace(/\$\{([A-Za-z0-9_]+)\}/g, (match, varName) => {
+      return process.env[varName] || match;
+    });
+  }
+};
+
+// src/app/agent/feedback/feedback_system.ts
+var AdvancedFeedbackSystem = class {
+  cumulativeScore = 0;
+  /**
+   * Gera feedback com base em um evento ocorrido.
+   * @param event O evento a ser avaliado.
+   * @returns Um objeto com a pontuação, mensagem e correção.
+   */
+  generateFeedback(event) {
+    if (event.event === "protocol_violation_direct_text") {
+      const penalty = -2.5;
+      this.cumulativeScore += penalty;
+      return {
+        score: penalty,
+        message: "Direct text response is a protocol violation. All communication must be done via the 'message_notify_dev' tool.",
+        correction: `
+  ## PROTOCOL VIOLATION \u2014 SEVERE
+  You sent a direct text response, which is strictly prohibited.
+  PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
+  You MUST use tools for all actions and communication.
+          `.trim()
+      };
+    }
+    return { score: 0, message: "No feedback for this event.", correction: "" };
+  }
+  getCumulativeScore() {
+    return this.cumulativeScore;
+  }
+};
+
+// src/app/agent/bluma/core/bluma.ts
+import path7 from "path";
+
+// src/app/agent/session_manger/session_manager.ts
+import path6 from "path";
+import os3 from "os";
+import { promises as fs7 } from "fs";
+var fileLocks = /* @__PURE__ */ new Map();
+async function withFileLock(file, fn) {
+  const prev = fileLocks.get(file) || Promise.resolve();
+  let release;
+  const p = new Promise((res) => release = res);
+  fileLocks.set(file, prev.then(() => p));
+  try {
+    const result = await fn();
+    return result;
+  } finally {
+    release();
+    if (fileLocks.get(file) === p) fileLocks.delete(file);
+  }
+}
+function expandHome(p) {
+  if (!p) return p;
+  if (p.startsWith("~")) {
+    return path6.join(os3.homedir(), p.slice(1));
+  }
+  return p;
+}
+function getPreferredAppDir() {
+  const fixed = path6.join(os3.homedir(), ".bluma-cli");
+  return path6.resolve(expandHome(fixed));
+}
+async function safeRenameWithRetry(src, dest, maxRetries = 6) {
+  let attempt = 0;
+  let lastErr;
+  const isWin = process.platform === "win32";
+  while (attempt <= maxRetries) {
+    try {
+      await fs7.rename(src, dest);
+      return;
+    } catch (e) {
+      lastErr = e;
+      const code = e && e.code || "";
+      const transient = code === "EPERM" || code === "EBUSY" || code === "ENOTEMPTY" || code === "EACCES";
+      if (!(isWin && transient) || attempt === maxRetries) break;
+      const backoff = Math.min(1e3, 50 * Math.pow(2, attempt));
+      await new Promise((r) => setTimeout(r, backoff));
+      attempt++;
+    }
+  }
+  try {
+    const data = await fs7.readFile(src);
+    await fs7.writeFile(dest, data);
+    await fs7.unlink(src).catch(() => {
+    });
+    return;
+  } catch (fallbackErr) {
+    throw lastErr || fallbackErr;
+  }
+}
+async function ensureSessionDir() {
+  const appDir = getPreferredAppDir();
+  const sessionDir = path6.join(appDir, "sessions");
+  await fs7.mkdir(sessionDir, { recursive: true });
+  return sessionDir;
+}
+async function loadOrcreateSession(sessionId2) {
+  const sessionDir = await ensureSessionDir();
+  const sessionFile = path6.join(sessionDir, `${sessionId2}.json`);
+  try {
+    await fs7.access(sessionFile);
+    const fileContent = await fs7.readFile(sessionFile, "utf-8");
+    const sessionData = JSON.parse(fileContent);
+    return [sessionFile, sessionData.conversation_history || []];
+  } catch (error) {
+    const newSessionData = {
+      session_id: sessionId2,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      conversation_history: []
+    };
+    await fs7.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    return [sessionFile, []];
+  }
+}
+async function saveSessionHistory(sessionFile, history) {
+  await withFileLock(sessionFile, async () => {
+    let sessionData;
+    try {
+      const dir = path6.dirname(sessionFile);
+      await fs7.mkdir(dir, { recursive: true });
+    } catch {
+    }
+    try {
+      const fileContent = await fs7.readFile(sessionFile, "utf-8");
+      sessionData = JSON.parse(fileContent);
+    } catch (error) {
+      const code = error && error.code;
+      if (code !== "ENOENT") {
+        if (error instanceof Error) {
+          console.warn(`Could not read or parse session file ${sessionFile}. Re-initializing. Error: ${error.message}`);
+        } else {
+          console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
+        }
+      }
+      const sessionId2 = path6.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");
+      } catch {
+      }
+    }
+    sessionData.conversation_history = 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 safeRenameWithRetry(tempSessionFile, sessionFile);
+    } catch (writeError) {
+      if (writeError instanceof Error) {
+        console.error(`Fatal error saving session to ${sessionFile}: ${writeError.message}`);
+      } else {
+        console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
+      }
+      try {
+        await fs7.unlink(tempSessionFile);
+      } catch {
+      }
+    }
+  });
+}
+
+// src/app/agent/core/prompt/prompt_builder.ts
+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.
+
+---
+
+## BEHAVIORAL RULES
+
+- **Identity:**  
+  You are BluMa (NomadEngenuity). Maintain professionalism and technical language.
+
+- **Communication:**  
+  ALL messages must be sent via 'message_notify_dev'.  
+  **No direct text replies to the developer.**
+
+- **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_system_environment>
+- Operating System: {os_type} ({os_version})
+- Architecture: {architecture}
+- Current Working Directory: {workdir}
+- Shell: {shell_type}
+- Username: {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"
@@ -893,15 +1547,15 @@ Before creating any diagram, ensure:
 Every diagram MUST render perfectly on first try. No exceptions.
 </mermaid_diagrams>
                        
-### MESSAGE RULES
-- Communicate with dev via message tools instead of direct text responses
-- Reply immediately to new dev messages before other operations
+<message_rules>
+- Communicate with dev'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 disruption and avoid blocking progress
-- Must send messages to developers with results and deliverables before signaling the completion of the task system.
-- Never forget to follow the "AGENT END TASK RULES" properly.
+- 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'
+</message_rules>
 
 
 ### Live Development Overlaps
@@ -924,9 +1578,9 @@ Every diagram MUST render perfectly on first try. No exceptions.
           - **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**.
                        
-### BLUMA NOTEBOOK
+<reasoning_rules>
 # YOUR THINKING ON A NOTEBOOK - MANDATORY USE
-CRITICAL: Your laptop (**sequentialThinking_nootebook**) is your ORGANIZED MIND
+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):
@@ -938,7 +1592,7 @@ CRITICAL: Your laptop (**sequentialThinking_nootebook**) is your ORGANIZED MIND
 - Architectural decisions (think through the options)
 
 ## HOW TO USE A NOTEBOOK:
-1. Start with **sequentialThinking_nootebook**
+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?
@@ -978,974 +1632,615 @@ CRITICAL: Your laptop (**sequentialThinking_nootebook**) is your ORGANIZED MIND
 	\u{1F5F8} Set up environment
 	[ ] Configure database
 
-### 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:
-- sequentialThinking_nootebook:0       \u2190 contains colon and dynamic suffix
-- sequentialThinking_nootebook 1       \u2190 contains space and number
-- sequentialThinking_nootebook#v2      \u2190 contains special character #
-- bluma__nootebook        \u2190 double underscore
-- sequentialThinking_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  
-- 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.
-- Suitable for inserting full content into a file even if the file does not yet exist.
-- Shell access is not required for file or directory creation when using this tool.
-- Always prefer this tool over shell_command when performing structured edits or creating files with specific content.
-- Ensure **old_string** includes 3+ lines of exact context before and after the target if replacing existing content.
-- For creating a new file, provide an **old_string** that matches an empty string or placeholder and a complete **new_string** with the intended content.
-- When generating or modifying todo.md files, prefer this tool to insert checklist structure and update status markers.
-- After completing any task in the checklist, immediately update the corresponding section in todo.md using this tool.
-- Reconstruct the entire file from task planning context if todo.md becomes outdated or inconsistent.
-- Track all progress related to planning and execution inside todo.md using text replacement only.
-
-      
-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 used to signal to the system that the current task has completed and that the agent can be placed in an idle state. 
-
-
-### 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>
-
-`;
-function getUnifiedSystemPrompt() {
-  const now = /* @__PURE__ */ new Date();
-  const collectedData = {
-    os_type: os2.type(),
-    os_version: os2.release(),
-    architecture: os2.arch(),
-    workdir: process.cwd(),
-    shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os2.userInfo().username || "Unknown",
-    current_date: now.toISOString().split("T")[0],
-    // Formato YYYY-MM-DD
-    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
-    locale: process.env.LANG || process.env.LC_ALL || "Unknown"
-  };
-  const finalEnv = {
-    os_type: "Unknown",
-    os_version: "Unknown",
-    workdir: "Unknown",
-    shell_type: "Unknown",
-    username: "Unknown",
-    architecture: "Unknown",
-    current_date: "Unknown",
-    timezone: "Unknown",
-    locale: "Unknown",
-    ...collectedData
-    // Os dados coletados sobrescrevem os padrões
-  };
-  let formattedPrompt = SYSTEM_PROMPT;
-  for (const key in finalEnv) {
-    const placeholder = `{${key}}`;
-    formattedPrompt = formattedPrompt.replace(new RegExp(placeholder, "g"), finalEnv[key]);
-  }
-  return formattedPrompt;
-}
+</reasoning_rules>
 
-// src/app/agent/tool_invoker.ts
-import { promises as fs6 } from "fs";
-import path5 from "path";
-import { fileURLToPath } from "url";
+### Tool Naming Policy
 
-// src/app/agent/tools/natives/shell_command.ts
-import os3 from "os";
-import { exec } from "child_process";
-function shellCommand(args) {
-  const { command, timeout = 20, cwd = process.cwd(), verbose = false } = args;
-  return new Promise((resolve) => {
-    const report = {
-      platform: os3.platform(),
-      // Coleta o sistema operacional (ex: 'win32', 'linux')
-      command,
-      cwd,
-      results: []
-    };
-    if (verbose) {
-      report.env = {
-        PATH: process.env.PATH || "NOT SET",
-        ComSpec: process.env.ComSpec || "NOT SET"
-        // Específico do Windows, útil para saber qual cmd está sendo usado
-      };
-    }
-    const childProcess = exec(
-      command,
-      {
-        // O diretório de trabalho para o comando.
-        cwd,
-        // O timeout em milissegundos. Se o comando exceder este tempo, ele será encerrado.
-        timeout: timeout * 1e3,
-        // A opção `shell` foi removida, pois `exec` usa o shell por padrão.
-        // Especificar a codificação garante que a saída seja tratada como texto UTF-8.
-        encoding: "utf-8"
-      },
-      // Este é o callback que será executado QUANDO o processo filho terminar,
-      // seja por sucesso, erro ou timeout.
-      (error, stdout, stderr) => {
-        const result = {
-          method: "child_process.exec",
-          status: "Success",
-          // Se `error` existir, ele contém o código de saída. Caso contrário, o código é 0 (sucesso).
-          code: error ? error.code || null : 0,
-          // Limpa espaços em branco do início e fim das saídas.
-          output: stdout.trim(),
-          error: stderr.trim()
-        };
-        if (error) {
-          if (error.killed) {
-            result.status = "Timeout";
-            result.error = `Command exceeded timeout of ${timeout} seconds. ${stderr.trim()}`.trim();
-          } else {
-            result.status = "Error";
-            result.error = `${error.message}
-${stderr.trim()}`.trim();
-          }
-        }
-        if (verbose) {
-          report.results.push(result);
-          resolve(JSON.stringify(report, null, 2));
-        } else {
-          resolve(JSON.stringify(result, null, 2));
-        }
-      }
-    );
-  });
-}
+Tool names must strictly follow the standard naming format:
 
-// src/app/agent/tools/natives/edit.ts
-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, "\\");
-}
-function ensureCorrectEdit(currentContent, oldString, newString, expectedReplacements) {
-  let finalOldString = oldString;
-  let finalNewString = newString;
-  let occurrences = currentContent.split(finalOldString).length - 1;
-  if (occurrences !== expectedReplacements && occurrences === 0) {
-    const unescapedOldString = unescapeLlmString(oldString);
-    const unescapedOccurrences = currentContent.split(unescapedOldString).length - 1;
-    if (unescapedOccurrences > 0) {
-      finalOldString = unescapedOldString;
-      finalNewString = unescapeLlmString(newString);
-      occurrences = unescapedOccurrences;
-    } else {
-      const trimmedOldString = oldString.trim();
-      const trimmedOccurrences = currentContent.split(trimmedOldString).length - 1;
-      if (trimmedOccurrences > 0) {
-        finalOldString = trimmedOldString;
-        finalNewString = newString.trim();
-        occurrences = trimmedOccurrences;
-      }
-    }
-  }
-  return [finalOldString, finalNewString, occurrences];
-}
-async function calculateEdit(filePath, oldString, newString, expectedReplacements) {
-  let currentContent = null;
-  let isNewFile = false;
-  let error = null;
-  let finalNewString = unescapeLlmString(newString).replace(/\r\n/g, "\n");
-  let finalOldString = oldString.replace(/\r\n/g, "\n");
-  let occurrences = 0;
-  try {
-    currentContent = await fs2.readFile(filePath, "utf-8");
-    currentContent = currentContent.replace(/\r\n/g, "\n");
-  } catch (e) {
-    if (e.code !== "ENOENT") {
-      error = { display: `Error reading file: ${e.message}`, raw: `Error reading file ${filePath}: ${e.message}` };
-      return { currentContent, newContent: "", occurrences: 0, error, isNewFile };
-    }
-  }
-  if (currentContent === null) {
-    if (oldString === "") {
-      isNewFile = true;
-      occurrences = 1;
-    } else {
-      error = { display: "File not found. Cannot apply edit. Use an empty old_string to create a new file.", raw: `File not found: ${filePath}` };
-    }
-  } else {
-    if (oldString === "") {
-      error = { display: "Failed to edit. Attempted to create a file that already exists.", raw: `File already exists, cannot create: ${filePath}` };
-    } else {
-      [finalOldString, finalNewString, occurrences] = ensureCorrectEdit(currentContent, finalOldString, finalNewString, expectedReplacements);
-      if (occurrences === 0) {
-        error = { display: "Failed to edit, could not find the string to replace.", raw: `0 occurrences found for old_string in ${filePath}. Check whitespace, indentation, and context.` };
-      } else if (occurrences !== expectedReplacements) {
-        error = { display: `Failed to edit, expected ${expectedReplacements} occurrence(s) but found ${occurrences}.`, raw: `Expected ${expectedReplacements} but found ${occurrences} for old_string in ${filePath}` };
-      }
-    }
-  }
-  let newContentResult = "";
-  if (!error) {
-    if (isNewFile) {
-      newContentResult = finalNewString;
-    } else if (currentContent !== null) {
-      newContentResult = currentContent.replaceAll(finalOldString, finalNewString);
-    }
-  }
-  return { currentContent, newContent: newContentResult, occurrences, error, isNewFile };
-}
-function createDiff(filename, oldContent, newContent) {
-  const diff = diffLines(oldContent, newContent, {
-    // `unified: 3` é o padrão para diffs, mostrando 3 linhas de contexto.
-    // `newlineIsToken: true` lida melhor com mudanças de quebra de linha.
-  });
-  let diffString = `--- a/${filename}
-+++ b/${filename}
-`;
-  diff.forEach((part) => {
-    const prefix = part.added ? "+" : part.removed ? "-" : " ";
-    part.value.split("\n").slice(0, -1).forEach((line) => {
-      diffString += `${prefix}${line}
-`;
-    });
-  });
-  return diffString;
-}
-async function editTool(args) {
-  const { file_path, old_string, new_string, expected_replacements = 1 } = args;
-  if (!path3.isAbsolute(file_path)) {
-    return { success: false, error: `Invalid parameters: file_path must be absolute.`, file_path };
-  }
-  if (file_path.includes("..")) {
-    return { success: false, error: `Invalid parameters: file_path cannot contain '..'.`, file_path };
-  }
-  try {
-    const editData = await calculateEdit(file_path, old_string, new_string, expected_replacements);
-    if (editData.error) {
-      return {
-        success: false,
-        error: `Execution failed: ${editData.error.display}`,
-        details: editData.error.raw,
-        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,
-        file_path,
-        description: `Created new file: ${relativePath}`,
-        message: `Created new file: ${file_path} with the provided content.`,
-        is_new_file: true,
-        occurrences: editData.occurrences,
-        relative_path: relativePath
-      };
-    } else {
-      const finalDiff = createDiff(filename, editData.currentContent || "", editData.newContent);
-      return {
-        success: true,
-        file_path,
-        description: `Modified ${relativePath} (${editData.occurrences} replacement(s)).`,
-        message: `Successfully modified file: ${file_path}. Diff of changes:
-${finalDiff}`,
-        is_new_file: false,
-        occurrences: editData.occurrences,
-        relative_path: relativePath
-      };
-    }
-  } catch (e) {
-    return {
-      success: false,
-      error: `An unexpected error occurred during the edit operation: ${e.message}`,
-      file_path
-    };
-  }
-}
+- Use: plain, unmodified, lowercase names
+- Do NOT use: special characters, extra spaces, version suffixes, or dynamic IDs
 
-// src/app/agent/tools/natives/message.ts
-import { v4 as uuidv4 } from "uuid";
-function messageNotifyDev(args) {
-  const { text_markdown } = args;
-  const notification = {
-    type: "message_notify_dev",
-    id: `notify_${uuidv4()}`,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    content: {
-      format: "markdown",
-      body: text_markdown
-    },
-    success: true,
-    delivered: true
-  };
-  return Promise.resolve(notification);
-}
+---
+
+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.
+- Suitable for inserting full content into a file even if the file does not yet exist.
+- Shell access is not required for file or directory creation when using this tool.
+- Always prefer this tool over shell_command when performing structured edits or creating files with specific content.
+- Ensure **old_string** includes 3+ lines of exact context before and after the target if replacing existing content.
+- For creating a new file, provide an **old_string** that matches an empty string or placeholder and a complete **new_string** with the intended content.
+- When generating or modifying todo.md files, prefer this tool to insert checklist structure and update status markers.
+- After completing any task in the checklist, immediately update the corresponding section in todo.md using this tool.
+- Reconstruct the entire file from task planning context if todo.md becomes outdated or inconsistent.
+- Track all progress related to planning and execution inside todo.md using text replacement only.
+</edit_tool_rules>
 
-// src/app/agent/tools/natives/ls.ts
-import { promises as fs3 } from "fs";
-import path4 from "path";
-var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
-  ".git",
-  ".gitignore",
-  ".venv",
-  "venv",
-  "node_modules",
-  "__pycache__",
-  "*.pyc",
-  ".vscode",
-  ".idea",
-  "dist",
-  "build",
-  "*.log",
-  ".DS_Store"
-]);
-async function ls(args) {
-  const {
-    directory_path = ".",
-    recursive = false,
-    ignore_patterns = [],
-    start_index = 0,
-    end_index,
-    show_hidden = false,
-    file_extensions,
-    max_depth
-  } = args;
-  try {
-    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]);
-    const normalizedExtensions = file_extensions?.map((ext) => ext.toLowerCase());
-    const allFiles = [];
-    const allDirs = [];
-    const walk = async (currentDir, currentDepth) => {
-      if (max_depth !== void 0 && currentDepth > max_depth) return;
-      const entries = await fs3.readdir(currentDir, { withFileTypes: true });
-      for (const entry of entries) {
-        const entryName = entry.name;
-        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;
-        }
-        if (entry.isDirectory()) {
-          allDirs.push(posixPath);
-          if (recursive) {
-            await walk(fullPath, currentDepth + 1);
-          }
-        } else if (entry.isFile()) {
-          if (!normalizedExtensions || normalizedExtensions.includes(path4.extname(entryName).toLowerCase())) {
-            allFiles.push(posixPath);
-          }
-        }
-      }
-    };
-    await walk(basePath, 0);
-    allFiles.sort();
-    allDirs.sort();
-    return {
-      success: true,
-      path: basePath.split(path4.sep).join("/"),
-      recursive,
-      total_files: allFiles.length,
-      total_directories: allDirs.length,
-      showing_files: `[${start_index}:${Math.min(end_index ?? allFiles.length, allFiles.length)}]`,
-      showing_directories: `[${start_index}:${Math.min(end_index ?? allDirs.length, allDirs.length)}]`,
-      files: allFiles.slice(start_index, end_index),
-      directories: allDirs.slice(start_index, end_index),
-      filters_applied: { ignore_patterns: [...allIgnorePatterns], show_hidden, file_extensions, max_depth }
-    };
-  } catch (e) {
-    return { success: false, error: e.message };
-  }
-}
+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.
 
-// src/app/agent/tools/natives/readLines.ts
-import { promises as fs4 } from "fs";
-async function readLines(args) {
-  const { filepath, start_line, end_line } = args;
-  try {
-    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 fs4.readFile(filepath, "utf-8");
-    const lines = fileContent.split("\n");
-    const total_lines = lines.length;
-    const startIndex = start_line - 1;
-    let endIndex = end_line;
-    if (startIndex >= total_lines) {
-      throw new Error(`start_line (${start_line}) exceeds file length (${total_lines} lines).`);
-    }
-    endIndex = Math.min(endIndex, total_lines);
-    const contentLines = lines.slice(startIndex, endIndex);
-    const content = contentLines.join("\n");
-    return {
-      success: true,
-      filepath,
-      content,
-      lines_read: contentLines.length,
-      start_line,
-      end_line: endIndex,
-      // Retorna o final real usado
-      total_file_lines: total_lines
-    };
-  } catch (e) {
-    return { success: false, error: e.message };
-  }
-}
 
-// src/app/agent/tools/natives/count_lines.ts
-import { createReadStream } from "fs";
-import { promises as fs5 } from "fs";
-import readline from "readline";
-async function countLines(args) {
-  const { filepath } = args;
-  try {
-    if (!(await fs5.stat(filepath)).isFile()) {
-      throw new Error(`File '${filepath}' not found or is not a file.`);
-    }
-    const fileStream = createReadStream(filepath);
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
-    });
-    let lineCount = 0;
-    for await (const line of rl) {
-      lineCount++;
-    }
-    return { success: true, filepath, line_count: lineCount };
-  } catch (e) {
-    return { success: false, error: e.message };
+<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>
+
+`;
+function getUnifiedSystemPrompt() {
+  const now = /* @__PURE__ */ new Date();
+  const collectedData = {
+    os_type: os4.type(),
+    os_version: os4.release(),
+    architecture: os4.arch(),
+    workdir: process.cwd(),
+    shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
+    username: os4.userInfo().username || "Unknown",
+    current_date: now.toISOString().split("T")[0],
+    // Formato YYYY-MM-DD
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
+    locale: process.env.LANG || process.env.LC_ALL || "Unknown"
+  };
+  const finalEnv = {
+    os_type: "Unknown",
+    os_version: "Unknown",
+    workdir: "Unknown",
+    shell_type: "Unknown",
+    username: "Unknown",
+    architecture: "Unknown",
+    current_date: "Unknown",
+    timezone: "Unknown",
+    locale: "Unknown",
+    ...collectedData
+    // Os dados coletados sobrescrevem os padrões
+  };
+  let formattedPrompt = SYSTEM_PROMPT;
+  for (const key in finalEnv) {
+    const placeholder = `{${key}}`;
+    formattedPrompt = formattedPrompt.replace(new RegExp(placeholder, "g"), finalEnv[key]);
   }
+  return formattedPrompt;
 }
 
-// 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 = 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 = [];
-    }
-  }
-  /**
-   * 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_dev", messageNotifyDev);
-    this.toolImplementations.set("ls_tool", ls);
-    this.toolImplementations.set("count_file_lines", countLines);
-    this.toolImplementations.set("read_file_lines", readLines);
-    this.toolImplementations.set("agent_end_task", 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/core/context-api/context_manager.ts
+function createApiContextWindow(fullHistory, maxTurns) {
+  if (!fullHistory.length) {
+    return [];
   }
-};
-
-// src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs7 } from "fs";
-import path6 from "path";
-import os4 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;
+  if (maxTurns === null || maxTurns === void 0) {
+    return [...fullHistory];
   }
-  // ... (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 = path6.dirname(__filename);
-    const defaultConfigPath = path6.resolve(__dirname, "config", "bluma-mcp.json");
-    const userConfigPath = path6.join(os4.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 || {}
+  const systemMessages = [];
+  let historyStartIndex = 0;
+  while (historyStartIndex < fullHistory.length && fullHistory[historyStartIndex].role === "system") {
+    systemMessages.push(fullHistory[historyStartIndex]);
+    historyStartIndex++;
+  }
+  const conversationHistory = fullHistory.slice(historyStartIndex);
+  const turns = [];
+  let currentTurn = [];
+  let turnsFound = 0;
+  const isDevOverlay = (m) => m?.role === "user" && m?.name === "dev_overlay";
+  for (let i = conversationHistory.length - 1; i >= 0; i--) {
+    const msg = conversationHistory[i];
+    currentTurn.unshift(msg);
+    const endsWithAgentEnd = msg.role === "assistant" && msg.tool_calls?.some((tc) => tc.function.name === "agent_end_task");
+    if (endsWithAgentEnd) {
+      turns.unshift([...currentTurn]);
+      currentTurn = [];
+      turnsFound++;
+      if (turnsFound >= maxTurns) {
+        break;
       }
-    };
-    if (Object.keys(mergedConfig.mcpServers).length === 0) {
-      return;
+      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...`
-        });
-        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.`);
+    const prev = conversationHistory[i - 1];
+    if (msg.role === "user" && !isDevOverlay(msg)) {
+      if (prev && prev.role === "assistant" && !prev.tool_calls?.some((tc) => tc.function.name === "agent_end_task")) {
+        const hasNonOverlay = currentTurn.some((m) => m.role !== "user" || !isDevOverlay(m));
+        if (hasNonOverlay) {
+          turns.unshift([...currentTurn]);
+          currentTurn = [];
         }
-      } catch (error) {
-        this.eventBus.emit("backend_message", {
-          type: "error",
-          message: `Failed to connect to server '${serverName}'.`
-        });
       }
     }
   }
-  async loadMcpConfig(configPath, configType) {
-    try {
-      const fileContent = await fs7.readFile(configPath, "utf-8");
-      const processedContent = this.replaceEnvPlaceholders(fileContent);
-      return JSON.parse(processedContent);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        if (configType === "User") {
-        }
-      } else {
-        console.warn(`[MCPClient] Warning: Error reading ${configType} config file ${configPath}.`, error);
-      }
-      return {};
-    }
+  if (currentTurn.length > 0) {
+    turns.unshift(currentTurn);
   }
-  /**
-   * Conecta-se a um servidor MCP baseado em Stdio, adaptando o comando para o SO atual.
-   */
-  async connectToStdioServer(serverName, config2) {
-    let commandToExecute = config2.command;
-    let argsToExecute = config2.args || [];
-    const isWindows = os4.platform() === "win32";
-    if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
-      if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
-        commandToExecute = argsToExecute[1];
-        argsToExecute = argsToExecute.slice(2);
-      } else {
-        console.warn(`[MCPClient] Formato de comando 'cmd /c' inesperado para '${serverName}' em sistema n\xE3o-Windows. O servidor ser\xE1 ignorado.`);
-        return;
-      }
-    }
-    const transport = new StdioClientTransport({
-      command: commandToExecute,
-      // Usa o comando adaptado
-      args: argsToExecute,
-      // Usa os argumentos adaptados
-      env: config2.env
+  const finalContext = systemMessages.concat(turns.flat());
+  return finalContext;
+}
+
+// src/app/agent/bluma/core/bluma.ts
+var BluMaAgent = class {
+  llm;
+  deploymentName;
+  sessionId;
+  sessionFile = "";
+  history = [];
+  eventBus;
+  mcpClient;
+  feedbackSystem;
+  maxContextTurns = 300;
+  isInterrupted = false;
+  constructor(sessionId2, eventBus2, llm, deploymentName, mcpClient, feedbackSystem) {
+    this.sessionId = sessionId2;
+    this.eventBus = eventBus2;
+    this.llm = llm;
+    this.deploymentName = deploymentName;
+    this.mcpClient = mcpClient;
+    this.feedbackSystem = feedbackSystem;
+    this.eventBus.on("user_interrupt", () => {
+      this.isInterrupted = true;
     });
-    const mcp = new Client({ name: `bluma-cli-client-for-${serverName}`, version: "1.0.0" });
-    await mcp.connect(transport);
-    this.sessions.set(serverName, mcp);
-    const toolsResult = await mcp.listTools();
-    for (const tool of toolsResult.tools) {
-      const prefixedToolName = `${serverName}_${tool.name}`;
-      this.globalToolsForLlm.push({
-        type: "function",
-        function: {
-          name: prefixedToolName,
-          description: tool.description || "",
-          parameters: tool.inputSchema
+    this.eventBus.on("dev_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() });
+      try {
+        if (this.sessionFile) {
+          await saveSessionHistory(this.sessionFile, this.history);
         }
-      });
-      this.toolToServerMap.set(prefixedToolName, {
-        server: serverName,
-        originalName: tool.name
-      });
-    }
-  }
-  async invoke(toolName, args) {
-    const route = this.toolToServerMap.get(toolName);
-    if (!route) {
-      return { error: `Ferramenta '${toolName}' n\xE3o encontrada ou registrada.` };
-    }
-    if (route.server === "native") {
-      return this.nativeToolInvoker.invoke(route.originalName, args);
-    } else {
-      const session = this.sessions.get(route.server);
-      if (!session) {
-        return { error: `Sess\xE3o para o servidor '${route.server}' n\xE3o encontrada.` };
+      } catch (e) {
+        this.eventBus.emit("backend_message", { type: "error", message: `Falha ao salvar hist\xF3rico ap\xF3s dev_overlay: ${e.message}` });
       }
-      const result = await session.callTool({ name: route.originalName, arguments: args });
-      return result.content;
+    });
+  }
+  async initialize() {
+    await this.mcpClient.nativeToolInvoker.initialize();
+    await this.mcpClient.initialize();
+    const [sessionFile, history] = await loadOrcreateSession(this.sessionId);
+    this.sessionFile = sessionFile;
+    this.history = history;
+    if (this.history.length === 0) {
+      const systemPrompt = getUnifiedSystemPrompt();
+      this.history.push({ role: "system", content: systemPrompt });
+      await saveSessionHistory(this.sessionFile, this.history);
     }
   }
   getAvailableTools() {
-    return this.globalToolsForLlm;
+    return this.mcpClient.getAvailableTools();
   }
-  // New: detailed list for UI with origin metadata
-  getAvailableToolsDetailed() {
-    const detailed = [];
-    for (const tool of this.globalToolsForLlm) {
-      const name = tool.function?.name;
-      if (!name) continue;
-      const route = this.toolToServerMap.get(name);
-      if (!route) continue;
-      const source = route.server === "native" ? "native" : "mcp";
-      detailed.push({ ...tool, source, server: route.server, originalName: route.originalName });
-    }
-    return detailed;
+  getUiToolsDetailed() {
+    return this.mcpClient.getAvailableToolsDetailed();
   }
-  async close() {
-    for (const [name, session] of this.sessions.entries()) {
+  async processTurn(userInput) {
+    this.isInterrupted = false;
+    const inputText = String(userInput.content || "").trim();
+    this.history.push({ role: "user", content: inputText });
+    await this._continueConversation();
+  }
+  async handleToolResponse(decisionData) {
+    const toolCall = decisionData.tool_calls[0];
+    let toolResultContent;
+    let shouldContinueConversation = true;
+    if (!this.sessionFile) {
+      const [sessionFile, history] = await loadOrcreateSession(this.sessionId);
+      this.sessionFile = sessionFile;
+      if (this.history.length === 0 && history.length > 0) {
+        this.history = history;
+      }
+    }
+    if (decisionData.type === "user_decision_execute") {
+      const toolName = toolCall.function.name;
+      const toolArgs = JSON.parse(toolCall.function.arguments);
+      let previewContent;
+      if (toolName === "edit_tool") {
+        previewContent = await this._generateEditPreview(toolArgs);
+      }
+      this.eventBus.emit("backend_message", {
+        type: "tool_call",
+        tool_name: toolName,
+        arguments: toolArgs,
+        preview: previewContent
+      });
       try {
-        await session.close();
+        if (this.isInterrupted) {
+          this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled before tool execution." });
+          return;
+        }
+        const result = await this.mcpClient.invoke(toolName, toolArgs);
+        let finalResult = result;
+        if (Array.isArray(result) && result.length > 0 && result[0].type === "text" && typeof result[0].text === "string") {
+          finalResult = result[0].text;
+        }
+        toolResultContent = typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult);
       } catch (error) {
-        console.error(`[MCPClient] Erro ao encerrar conex\xE3o com '${name}':`, error);
+        toolResultContent = JSON.stringify({
+          error: `Tool execution failed: ${error.message}`,
+          details: error.data || "No additional details."
+        });
+      }
+      this.eventBus.emit("backend_message", { type: "tool_result", tool_name: toolName, result: toolResultContent });
+      if (toolName.includes("agent_end_task")) {
+        shouldContinueConversation = false;
+        this.eventBus.emit("backend_message", { type: "done", status: "completed" });
       }
+    } else {
+      toolResultContent = "The user declined to execute this tool...";
     }
-  }
-  replaceEnvPlaceholders(content) {
-    return content.replace(/\$\{([A-Za-z0-9_]+)\}/g, (match, varName) => {
-      return process.env[varName] || match;
-    });
-  }
-};
-
-// src/app/agent/feedback/feedback_system.ts
-var AdvancedFeedbackSystem = class {
-  cumulativeScore = 0;
-  /**
-   * Gera feedback com base em um evento ocorrido.
-   * @param event O evento a ser avaliado.
-   * @returns Um objeto com a pontuação, mensagem e correção.
-   */
-  generateFeedback(event) {
-    if (event.event === "protocol_violation_direct_text") {
-      const penalty = -2.5;
-      this.cumulativeScore += penalty;
-      return {
-        score: penalty,
-        message: "Direct text response is a protocol violation. All communication must be done via the 'message_notify_dev' tool.",
-        correction: `
-  ## PROTOCOL VIOLATION \u2014 SEVERE
-  You sent a direct text response, which is strictly prohibited.
-  PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
-  You MUST use tools for all actions and communication.
-          `.trim()
-      };
+    this.history.push({ role: "tool", tool_call_id: toolCall.id, content: toolResultContent });
+    await saveSessionHistory(this.sessionFile, this.history);
+    if (shouldContinueConversation && !this.isInterrupted) {
+      await this._continueConversation();
     }
-    return { score: 0, message: "No feedback for this event.", correction: "" };
-  }
-  getCumulativeScore() {
-    return this.cumulativeScore;
   }
-};
+  async _generateEditPreview(toolArgs) {
+    try {
+      const editData = await calculateEdit(toolArgs.file_path, toolArgs.old_string, toolArgs.new_string, toolArgs.expected_replacements || 1);
+      if (editData.error) {
+        return `Failed to generate diff:
 
-// src/app/agent/core/context-api/context_manager.ts
-function createApiContextWindow(fullHistory, maxTurns) {
-  if (!fullHistory.length) {
-    return [];
-  }
-  if (maxTurns === null || maxTurns === void 0) {
-    return [...fullHistory];
-  }
-  const systemMessages = [];
-  let historyStartIndex = 0;
-  while (historyStartIndex < fullHistory.length && fullHistory[historyStartIndex].role === "system") {
-    systemMessages.push(fullHistory[historyStartIndex]);
-    historyStartIndex++;
-  }
-  const conversationHistory = fullHistory.slice(historyStartIndex);
-  const turns = [];
-  let currentTurn = [];
-  let turnsFound = 0;
-  const isDevOverlay = (m) => m?.role === "user" && m?.name === "dev_overlay";
-  for (let i = conversationHistory.length - 1; i >= 0; i--) {
-    const msg = conversationHistory[i];
-    currentTurn.unshift(msg);
-    const endsWithAgentEnd = msg.role === "assistant" && msg.tool_calls?.some((tc) => tc.function.name === "agent_end_task");
-    if (endsWithAgentEnd) {
-      turns.unshift([...currentTurn]);
-      currentTurn = [];
-      turnsFound++;
-      if (turnsFound >= maxTurns) {
-        break;
+${editData.error.display}`;
       }
-      continue;
+      const filename = path7.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}`;
     }
-    const prev = conversationHistory[i - 1];
-    if (msg.role === "user" && !isDevOverlay(msg)) {
-      if (prev && prev.role === "assistant" && !prev.tool_calls?.some((tc) => tc.function.name === "agent_end_task")) {
-        const hasNonOverlay = currentTurn.some((m) => m.role !== "user" || !isDevOverlay(m));
-        if (hasNonOverlay) {
-          turns.unshift([...currentTurn]);
-          currentTurn = [];
+  }
+  async _continueConversation() {
+    try {
+      if (this.isInterrupted) {
+        this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+        return;
+      }
+      const contextWindow = createApiContextWindow(this.history, this.maxContextTurns);
+      const response = await this.llm.chatCompletion({
+        model: this.deploymentName,
+        messages: contextWindow,
+        tools: this.mcpClient.getAvailableTools(),
+        tool_choice: "required",
+        parallel_tool_calls: false
+      });
+      if (this.isInterrupted) {
+        this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+        return;
+      }
+      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 toolToCall = message.tool_calls[0];
+        const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
+        if (isSafeTool) {
+          await this.handleToolResponse({ type: "user_decision_execute", tool_calls: message.tool_calls });
+        } else {
+          const toolName = toolToCall.function.name;
+          if (toolName === "edit_tool") {
+            const args = JSON.parse(toolToCall.function.arguments);
+            const previewContent = await this._generateEditPreview(args);
+            this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: message.tool_calls, preview: previewContent });
+          } else {
+            this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: message.tool_calls });
+          }
         }
+      } else if (message.content) {
+        this.eventBus.emit("backend_message", { type: "assistant_message", content: message.content });
+        const feedback = this.feedbackSystem.generateFeedback({
+          event: "protocol_violation_direct_text",
+          details: { violationContent: message.content }
+        });
+        this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: message.content });
+        this.history.push({ role: "system", content: feedback.correction });
+        await this._continueConversation();
+      } else {
+        this.eventBus.emit("backend_message", { type: "info", message: "Agent is thinking... continuing reasoning cycle." });
+        await this._continueConversation();
       }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "An unknown API error occurred.";
+      this.eventBus.emit("backend_message", { type: "error", message: errorMessage });
+    } finally {
+      await saveSessionHistory(this.sessionFile, this.history);
     }
   }
-  if (currentTurn.length > 0) {
-    turns.unshift(currentTurn);
+};
+
+// src/app/agent/core/llm.ts
+var OpenAIAdapter = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async chatCompletion(params) {
+    const resp = await this.client.chat.completions.create({
+      model: params.model,
+      messages: params.messages,
+      tools: params.tools,
+      tool_choice: params.tool_choice,
+      parallel_tool_calls: params.parallel_tool_calls
+    });
+    return resp;
   }
-  const finalContext = systemMessages.concat(turns.flat());
-  return finalContext;
+};
+
+// src/app/agent/subagents/registry.ts
+var subAgentRegistry = {};
+function registerSubAgent(subAgent) {
+  for (const cap of subAgent.capabilities) {
+    subAgentRegistry[cap] = subAgent;
+  }
+}
+function getSubAgentByCommand(cmd) {
+  return subAgentRegistry[cmd];
+}
+
+// src/app/agent/subagents/init/init_system_prompt.ts
+import os5 from "os";
+var SYSTEM_PROMPT2 = `
+
+### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
+You extend the BluMa multi-agent architecture and handle the project bootstrapping/init workflow: scanning the repository, inferring stack, and generating a high-quality BluMa.md with actionable project context.
+
+---
+
+## BEHAVIORAL RULES
+
+- Identity:
+  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.
+
+- Task Completion:
+  When the init task is completed, immediately invoke 'agent_end_task' without dev permissions.
+
+- Tool Rules:
+  Never make parallel tool calls.
+  Only use 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_system_environment>
+- Operating System: {os_type} ({os_version})
+- Architecture: {architecture}
+- Current Working Directory: {workdir}
+- Shell: {shell_type}
+- Username: {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
+- 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) 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'
+</message_rules>
+
+<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 \u2013 Which files? What changes? What order?
+4. Track progress \u2013 Check off completed steps
+5. Write down decisions \u2013 Why did you choose this approach?
+6. Update continuously \u2013 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 future steps/to-dos in thought; put them strictly in remaining_tasks, using the mandated checklist markers.
+
+- remaining_tasks: Checklist list of high-level upcoming tasks.
+  Format is mandatory:
+  - "\u{1F5F8}" \u2192 for tasks not yet done (pending)
+  - "[ ]" \u2192 for tasks already completed
+</reasoning_rules>
+
+<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.
+- Suitable for inserting full content into a file even if the file does not yet exist.
+- Shell access is not required for file or directory creation when using this tool.
+- Always prefer this tool over shell_command when performing structured edits or creating files with specific content.
+- Ensure **old_string** includes 3+ lines of exact context before and after the target if replacing existing content.
+- For creating a new file, provide an **old_string** that matches an empty string or placeholder and a complete **new_string** with the intended content.
+- When generating or modifying todo.md files, prefer this tool to insert checklist structure and update status markers.
+- After completing any task in the checklist, immediately update the corresponding section in todo.md using this tool.
+- Reconstruct the entire file from task planning context if todo.md becomes outdated or inconsistent.
+- Track all progress related to planning and execution inside todo.md using text replacement only.
+</edit_tool_rules>
+
+
+### Tool Naming Policy
+- Use plain, unmodified, lowercase tool names
+- No special characters, spaces, or version suffixes
+
+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
+
+
+## INIT SUBAGENT OBJECTIVE
+- Map repository structure and significant files.
+- Infer tech stack (frameworks, package managers, languages, build/test tools).
+- Identify entry points, configuration files, and scripts.
+- Produce BluMa.md with:
+  - Project overview and goals inferred from code/docs
+  - Tech stack summary
+  - Directory map (high-level)
+  - Key configs and scripts
+  - Known tasks or next steps for agents
+- Always use tools (ls, readLines, count_lines, shell_command, edit_tool) to gather evidence before writing.
+- 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.
+- 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.
+
+## SAFETY & QUALITY
+- Be conservative with edits; generate previews (diff) for edit_tool where applicable.
+- Keep file system operations idempotent and explicit.
+- Prefer performance-efficient scans (avoid reading entire large binaries).
+- Respect test environment constraints.
+
+## 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)
+4) Write BluMa.md via edit_tool
+5) Announce completion and agent_end_task
+
+
+`;
+function getInitPrompt() {
+  const now = /* @__PURE__ */ new Date();
+  const collectedData = {
+    os_type: os5.type(),
+    os_version: os5.release(),
+    architecture: os5.arch(),
+    workdir: process.cwd(),
+    shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
+    username: os5.userInfo().username || "Unknown",
+    current_date: now.toISOString().split("T")[0],
+    // Formato YYYY-MM-DD
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
+    locale: process.env.LANG || process.env.LC_ALL || "Unknown"
+  };
+  const finalEnv = {
+    os_type: "Unknown",
+    os_version: "Unknown",
+    workdir: "Unknown",
+    shell_type: "Unknown",
+    username: "Unknown",
+    architecture: "Unknown",
+    current_date: "Unknown",
+    timezone: "Unknown",
+    locale: "Unknown",
+    ...collectedData
+    // Os dados coletados sobrescrevem os padrões
+  };
+  let formattedPrompt = SYSTEM_PROMPT2;
+  for (const key in finalEnv) {
+    const placeholder = `{${key}}`;
+    formattedPrompt = formattedPrompt.replace(new RegExp(placeholder, "g"), finalEnv[key]);
+  }
+  return formattedPrompt;
 }
 
-// src/app/agent/agent.ts
-var globalEnvPath = path7.join(os5.homedir(), ".bluma-cli", ".env");
-dotenv.config({ path: globalEnvPath });
-var Agent = class {
-  client;
-  deploymentName;
-  sessionId;
-  sessionFile = "";
+// src/app/agent/subagents/base_llm_subagent.ts
+var BaseLLMSubAgent = class {
+  ctx;
   history = [];
-  eventBus;
-  mcpClient;
-  feedbackSystem;
-  isInitialized = false;
-  maxContextTurns = 300;
+  sessionFile = "";
+  maxContextTurns = 160;
   isInterrupted = false;
-  // <-- NOVO: Flag de interrupção
-  constructor(sessionId2, eventBus2) {
-    this.sessionId = sessionId2;
-    this.eventBus = eventBus2;
-    this.eventBus.on("user_interrupt", () => {
+  async execute(input, ctx) {
+    this.ctx = ctx;
+    this.isInterrupted = false;
+    this.ctx.eventBus.on("user_interrupt", () => {
       this.isInterrupted = true;
     });
-    this.eventBus.on("dev_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()
-      });
-      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}` });
-      }
-    });
-    const nativeToolInvoker = new ToolInvoker();
-    this.mcpClient = new MCPClient(nativeToolInvoker, eventBus2);
-    this.feedbackSystem = new AdvancedFeedbackSystem();
-    const apiKey = "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";
-    const modelName = "openrouter/horizon-alpha";
-    if (!apiKey || !modelName) {
-      throw new Error("Chave de API ou nome do modelo do OpenRouter n\xE3o encontrados.");
-    }
-    this.deploymentName = modelName;
-    this.client = new OpenAI({
-      // Configuração do cliente OpenAI hospedado no  OpenRouter
-      apiKey,
-      baseURL: "https://openrouter.ai/api/v1",
-      // <-- URL base do OpenRouter
-      defaultHeaders: {
-        "HTTP-Referer": "http://localhost:3000",
-        // Substitua pelo seu site ou app
-        "X-Title": "Bluma CLI Agent"
-        // Substitua pelo nome do seu projeto
-      }
-    });
+    await this.initializeHistory();
+    this.history.push({ role: "user", content: typeof input === "string" ? input : JSON.stringify(input) });
+    await this._continueConversation();
+    return { history: this.history };
   }
-  /**
-   * Inicializa o agente, carregando ou criando uma sessão e preparando o histórico.
-   * Também inicializa o MCPClient e o ToolInvoker.
-   */
-  async initialize() {
-    await this.mcpClient.nativeToolInvoker.initialize();
-    await this.mcpClient.initialize();
-    const [sessionFile, history] = await loadOrcreateSession(this.sessionId);
+  async initializeHistory() {
+    const sessionId2 = `${this.id}`;
+    const [sessionFile, history] = await loadOrcreateSession(sessionId2);
     this.sessionFile = sessionFile;
-    this.history = history;
+    this.history = history || [];
+    const systemPromptContent = getInitPrompt();
     if (this.history.length === 0) {
-      let systemPrompt = getUnifiedSystemPrompt();
-      this.history.push({ role: "system", content: systemPrompt });
-      await saveSessionHistory(this.sessionFile, this.history);
-    }
-    this.isInitialized = true;
-  }
-  getAvailableTools() {
-    return this.mcpClient.getAvailableTools();
-  }
-  // UI helper: detailed tools with origin metadata
-  getUiToolsDetailed() {
-    return this.mcpClient.getAvailableToolsDetailed();
-  }
-  async processTurn(userInput) {
-    this.isInterrupted = false;
-    this.history.push({ role: "user", content: userInput.content });
-    await this._continueConversation();
-  }
-  /**
-   * Lida com a decisão do usuário (aceitar/recusar) sobre uma chamada de ferramenta.
-   * Garante que uma mensagem de 'role: tool' seja sempre adicionada ao histórico.
-   */
-  async handleToolResponse(decisionData) {
-    const toolCall = decisionData.tool_calls[0];
-    let toolResultContent;
-    let shouldContinueConversation = true;
-    if (!this.sessionFile) {
-      const [sessionFile, history] = await loadOrcreateSession(this.sessionId);
-      this.sessionFile = sessionFile;
-      if (this.history.length === 0 && history.length > 0) {
-        this.history = history;
-      }
-    }
-    if (decisionData.type === "user_decision_execute") {
-      const toolName = toolCall.function.name;
-      const toolArgs = JSON.parse(toolCall.function.arguments);
-      let previewContent;
-      if (toolName === "edit_tool") {
-        previewContent = await this._generateEditPreview(toolArgs);
-      }
-      this.eventBus.emit("backend_message", {
-        type: "tool_call",
-        tool_name: toolName,
-        arguments: toolArgs,
-        preview: previewContent
+      this.history.push({
+        role: "system",
+        content: systemPromptContent
       });
-      try {
-        if (this.isInterrupted) {
-          this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled before tool execution." });
-          return;
-        }
-        const result = await this.mcpClient.invoke(toolName, toolArgs);
-        let finalResult = result;
-        if (Array.isArray(result) && result.length > 0 && result[0].type === "text" && typeof result[0].text === "string") {
-          finalResult = result[0].text;
-        }
-        toolResultContent = typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult);
-      } catch (error) {
-        toolResultContent = JSON.stringify({
-          error: `Tool execution failed: ${error.message}`,
-          details: error.data || "No additional details."
-        });
-      }
-      this.eventBus.emit("backend_message", { type: "tool_result", tool_name: toolName, result: toolResultContent });
-      if (toolName.includes("agent_end_task")) {
-        shouldContinueConversation = false;
-        this.eventBus.emit("backend_message", { type: "done", status: "completed" });
-      }
-    } else {
-      toolResultContent = "The user declined to execute this tool...";
-    }
-    this.history.push({
-      role: "tool",
-      tool_call_id: toolCall.id,
-      content: toolResultContent
-    });
-    await saveSessionHistory(this.sessionFile, this.history);
-    if (shouldContinueConversation && !this.isInterrupted) {
-      await this._continueConversation();
+      await saveSessionHistory(this.sessionFile, this.history);
     }
   }
-  /**
-   * Método central que chama a API do LLM e processa a resposta,
-   * com lógica de feedback e auto-aprovação de ferramentas.
-   */
-  // Adicione este método dentro da classe Agent
   async _generateEditPreview(toolArgs) {
     try {
       const editData = await calculateEdit(toolArgs.file_path, toolArgs.old_string, toolArgs.new_string, toolArgs.expected_replacements || 1);
@@ -1954,7 +2249,7 @@ var Agent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path7.basename(toolArgs.file_path);
+      const filename = toolArgs.file_path?.split(/[\/]/).pop() || "file";
       return createDiff(filename, editData.currentContent || "", editData.newContent);
     } catch (e) {
       return `An unexpected error occurred while generating the edit preview: ${e.message}`;
@@ -1963,79 +2258,266 @@ ${editData.error.display}`;
   async _continueConversation() {
     try {
       if (this.isInterrupted) {
-        this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+        this.emitEvent("info", { message: "SubAgent task cancelled by user." });
         return;
       }
-      const contextWindow = createApiContextWindow(this.history, this.maxContextTurns);
-      const response = await this.client.chat.completions.create({
-        model: this.deploymentName,
+      const contextWindow = this.history.slice(-this.maxContextTurns);
+      const response = await this.ctx.llm.chatCompletion({
+        model: this.ctx.policy?.llmDeployment || "default",
         messages: contextWindow,
-        tools: this.mcpClient.getAvailableTools(),
+        tools: this.ctx.mcpClient.getAvailableTools(),
         tool_choice: "required",
         parallel_tool_calls: false
       });
       if (this.isInterrupted) {
-        this.eventBus.emit("backend_message", { type: "info", message: "Agent task cancelled by user." });
+        this.emitEvent("info", { message: "SubAgent task cancelled by user." });
         return;
       }
       const message = response.choices[0].message;
       this.history.push(message);
       if (message.tool_calls) {
-        const autoApprovedTools = [
-          "agent_end_task",
-          "message_notify_dev",
-          "sequentialThinking_nootebook"
-        ];
-        const toolToCall = message.tool_calls[0];
-        const isSafeTool = autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
-        if (isSafeTool) {
-          await this.handleToolResponse({ type: "user_decision_execute", tool_calls: message.tool_calls });
-        } else {
-          const toolName = toolToCall.function.name;
-          if (toolName === "edit_tool") {
-            const args = JSON.parse(toolToCall.function.arguments);
-            const previewContent = await this._generateEditPreview(args);
-            this.eventBus.emit("backend_message", {
-              type: "confirmation_request",
-              tool_calls: message.tool_calls,
-              preview: previewContent
-            });
-          } else {
-            this.eventBus.emit("backend_message", {
-              type: "confirmation_request",
-              tool_calls: message.tool_calls
-            });
-          }
+        await this._handleToolExecution({ type: "user_decision_execute", tool_calls: message.tool_calls });
+        const lastToolName = message.tool_calls[0].function.name;
+        if (!lastToolName.includes("agent_end_task") && !this.isInterrupted) {
+          await this._continueConversation();
         }
       } else if (message.content) {
-        this.eventBus.emit("backend_message", {
-          type: "assistant_message",
-          content: message.content
-        });
-        const feedback = this.feedbackSystem.generateFeedback({
-          event: "protocol_violation_direct_text",
-          details: { violationContent: message.content }
-        });
-        this.eventBus.emit("backend_message", {
-          type: "protocol_violation",
-          message: feedback.message,
-          content: message.content
-        });
-        this.history.push({
-          role: "system",
-          content: feedback.correction
-        });
-        await this._continueConversation();
+        this.emitEvent("assistant_message", { content: message.content });
+        this.emitEvent("protocol_violation", { message: "Direct text emission detected from subagent.", content: message.content });
       } else {
-        this.eventBus.emit("backend_message", { type: "info", message: "Agent is thinking... continuing reasoning cycle." });
-        await this._continueConversation();
+        this.emitEvent("info", { message: "SubAgent is thinking... continuing reasoning cycle." });
       }
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "An unknown API error occurred.";
-      this.eventBus.emit("backend_message", { type: "error", message: errorMessage });
+      const errorMessage = error?.message || "An unknown API error occurred.";
+      this.emitEvent("error", { message: errorMessage });
     } finally {
-      await saveSessionHistory(this.sessionFile, this.history);
+      if (this.sessionFile) await saveSessionHistory(this.sessionFile, this.history);
+    }
+  }
+  // MÉTODO REMOVIDO
+  // public async handleConfirmation(decisionData: { type: string; tool_calls: any[] }) {
+  //   await this._handleToolExecution(decisionData);
+  //   if (!this.isInterrupted) {
+  //     await this._continueConversation();
+  //   }
+  // }
+  async _handleToolExecution(decisionData) {
+    const toolCall = decisionData.tool_calls[0];
+    let toolResultContent;
+    if (decisionData.type === "user_decision_execute") {
+      const toolName = toolCall.function.name;
+      const toolArgs = JSON.parse(toolCall.function.arguments);
+      let previewContent;
+      if (toolName === "edit_tool") {
+        previewContent = await this._generateEditPreview(toolArgs);
+      }
+      this.emitEvent("tool_call", {
+        tool_name: toolName,
+        arguments: toolArgs,
+        preview: previewContent
+      });
+      try {
+        if (this.isInterrupted) {
+          this.emitEvent("info", { message: "SubAgent task cancelled before tool execution." });
+          toolResultContent = JSON.stringify({ error: "Task cancelled by user before execution." });
+        } else {
+          const result = await this.ctx.mcpClient.invoke(toolName, toolArgs);
+          let finalResult = result;
+          if (Array.isArray(result) && result.length > 0 && result[0].type === "text" && typeof result[0].text === "string") {
+            finalResult = result[0].text;
+          }
+          toolResultContent = typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult);
+        }
+      } catch (error) {
+        toolResultContent = JSON.stringify({ error: `Tool execution failed: ${error.message}`, details: error.data || "No additional details." });
+      }
+      this.emitEvent("tool_result", { tool_name: toolName, result: toolResultContent });
+      if (toolName.includes("agent_end_task")) {
+        this.emitEvent("done", { status: "completed" });
+      }
+    } else {
+      toolResultContent = "Tool execution was declined.";
+    }
+    this.history.push({ role: "tool", tool_call_id: toolCall.id, content: toolResultContent });
+  }
+  // Utilitários: emitir eventos, chamar tools, etc
+  emitEvent(type, payload) {
+    this.ctx.eventBus.emit("backend_message", { type, ...payload });
+  }
+};
+
+// src/app/agent/subagents/init/init_subagent.ts
+var InitAgentImpl = class extends BaseLLMSubAgent {
+  id = "init_subagent";
+  capabilities = ["/init"];
+  async execute(input, ctx) {
+    this.ctx = ctx;
+    this.isInterrupted = false;
+    this.ctx.eventBus.on("user_interrupt", () => {
+      this.isInterrupted = true;
+    });
+    await this.initializeHistory();
+    const seed = `
+    Scan the current project repository comprehensively. 
+    Map the directory structure (excluding heavy/ignored folders), infer the technology stack from manifests and configs, identify entry points and useful scripts, and analyze module relationships and architectural patterns. 
+    Then draft a concise, actionable BluMa.md that includes: project overview, detected stack, a summarized directory tree with brief annotations, key configs and scripts, useful CLI commands, and relevant operational notes for BluMa. 
+    Use only evidence gathered via tools; do not invent content. 
+    If overwriting an existing BluMa.md is required, follow non-destructive policies and request confirmation as per protocol.
+    `;
+    const combined = seed;
+    this.history.push({ role: "user", content: combined });
+    await this._continueConversation();
+    return { history: this.history };
+  }
+};
+var InitSubAgent = new InitAgentImpl();
+
+// src/app/agent/subagents/subagents_bluma.ts
+registerSubAgent(InitSubAgent);
+var SubAgentsBluMa = class {
+  eventBus;
+  mcpClient;
+  toolInvoker;
+  llm;
+  deploymentName;
+  projectRoot;
+  policy;
+  logger;
+  constructor(params) {
+    this.eventBus = params.eventBus;
+    this.mcpClient = params.mcpClient;
+    this.toolInvoker = params.toolInvoker;
+    this.llm = params.llm;
+    this.deploymentName = params.deploymentName;
+    this.projectRoot = params.projectRoot || process.cwd();
+    this.policy = params.policy;
+    this.logger = params.logger;
+  }
+  // Recebe dados do front (ex.: { content: inputText } vindo de /init)
+  // e faz o roteamento para o subagente adequado com base no comando.
+  async registerAndDispatch(frontPayload) {
+    const { command, content, ...rest } = frontPayload || {};
+    const resolvedCommand = this.resolveCommand({ command, content });
+    if (!resolvedCommand) {
+      this.emit("error", { message: "Nenhum comando/subagente correspondente encontrado." });
+      return { ok: false, error: "unknown_command" };
+    }
+    const subAgent = getSubAgentByCommand(resolvedCommand);
+    if (!subAgent) {
+      this.emit("error", { message: `Subagente n\xE3o registrado para ${resolvedCommand}` });
+      return { ok: false, error: "unregistered_subagent" };
+    }
+    const ctx = {
+      projectRoot: this.projectRoot,
+      eventBus: this.eventBus,
+      mcpClient: this.mcpClient,
+      toolInvoker: this.toolInvoker,
+      llm: this.llm,
+      policy: { llmDeployment: this.deploymentName, ...this.policy || {} },
+      logger: this.logger
+    };
+    const inputForAgent = content ?? JSON.stringify({ content, ...rest });
+    this.emit("info", { message: `[SubAgentsBluMa] Dispatch -> ${resolvedCommand}` });
+    return subAgent.execute(inputForAgent, ctx);
+  }
+  // Estratégia simples: se o payload explicitamente vier de /init, use "/init".
+  // Caso haja command explícito, usa-o. Caso contrário, heurística com base no conteúdo.
+  resolveCommand(payload) {
+    if (payload.command && typeof payload.command === "string") return payload.command;
+    const text = String(payload.content || "").trim();
+    if (!text) return "/init";
+    if (text.startsWith("/")) return text.split(/\s+/)[0];
+    return "/init";
+  }
+  emit(type, data) {
+    this.eventBus.emit("backend_message", { type, ...data });
+  }
+};
+
+// src/app/agent/agent.ts
+var globalEnvPath = path8.join(os6.homedir(), ".bluma-cli", ".env");
+dotenv.config({ path: globalEnvPath });
+var Agent = class {
+  sessionId;
+  eventBus;
+  mcpClient;
+  feedbackSystem;
+  // Mantido caso UI dependa de eventos
+  llm;
+  deploymentName;
+  core;
+  // Delegado
+  subAgents;
+  // Orquestrador de subagentes
+  toolInvoker;
+  constructor(sessionId2, eventBus2) {
+    this.sessionId = sessionId2;
+    this.eventBus = eventBus2;
+    const nativeToolInvoker = new ToolInvoker();
+    this.toolInvoker = nativeToolInvoker;
+    this.mcpClient = new MCPClient(nativeToolInvoker, eventBus2);
+    this.feedbackSystem = new AdvancedFeedbackSystem();
+    const endpoint = process.env.AZURE_OPENAI_ENDPOINT;
+    const apiKey = process.env.AZURE_OPENAI_API_KEY;
+    const apiVersion = process.env.AZURE_OPENAI_API_VERSION;
+    this.deploymentName = process.env.AZURE_OPENAI_DEPLOYMENT || "";
+    if (!endpoint || !apiKey || !apiVersion || !this.deploymentName) {
+      const errorMessage = `Uma ou mais vari\xE1veis de ambiente Azure OpenAI n\xE3o foram encontradas. Verifique em: ${globalEnvPath} ou nas vari\xE1veis de sistema.`;
+      throw new Error(errorMessage);
+    }
+    const openai = new OpenAI({
+      // Configuração do cliente OpenAI hospedado no Azure
+      apiKey,
+      baseURL: `${endpoint}/openai/deployments/${this.deploymentName}`,
+      defaultQuery: { "api-version": apiVersion },
+      defaultHeaders: { "api-key": apiKey }
+    });
+    this.llm = new OpenAIAdapter(openai);
+    this.core = new BluMaAgent(
+      this.sessionId,
+      this.eventBus,
+      this.llm,
+      this.deploymentName,
+      this.mcpClient,
+      this.feedbackSystem
+    );
+    this.subAgents = new SubAgentsBluMa({
+      eventBus: this.eventBus,
+      mcpClient: this.mcpClient,
+      toolInvoker: this.toolInvoker,
+      llm: this.llm,
+      deploymentName: this.deploymentName,
+      projectRoot: process.cwd()
+    });
+  }
+  async initialize() {
+    await this.core.initialize();
+  }
+  getAvailableTools() {
+    return this.core.getAvailableTools();
+  }
+  getUiToolsDetailed() {
+    return this.core.getUiToolsDetailed();
+  }
+  async processTurn(userInput) {
+    const inputText = String(userInput.content || "").trim();
+    if (inputText === "/init" || inputText.startsWith("/init ")) {
+      await this.dispatchToSubAgent({ command: "/init", content: inputText });
+      return;
     }
+    await this.core.processTurn({ content: inputText });
+  }
+  async handleToolResponse(decisionData) {
+    await this.core.handleToolResponse(decisionData);
+  }
+  // Novo: processamento via SubAgents (ex.: payload vindo do front /init)
+  async dispatchToSubAgent(payload) {
+    return this.subAgents.registerAndDispatch(payload);
+  }
+  // Compat: snapshot imutável do histórico para testes/UI (não expõe referência mutável)
+  getHistorySnapshot() {
+    const coreHistory = this.core.history;
+    return coreHistory ? coreHistory.map((m) => ({ ...m })) : [];
   }
 };
 
@@ -2071,7 +2553,7 @@ import { Box as Box9 } from "ink";
 
 // src/app/ui/components/toolCallRenderers.tsx
 import { Box as Box8, Text as Text8 } from "ink";
-import path8 from "path";
+import path9 from "path";
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 var formatArgumentsForDisplay = (args) => {
   if (typeof args === "string") {
@@ -2104,7 +2586,7 @@ var renderLsTool2 = ({ args }) => {
   } catch (e) {
     directoryPath = "Error parsing arguments";
   }
-  const finalDirectoryName = path8.basename(directoryPath);
+  const finalDirectoryName = path9.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 " }),
@@ -2124,7 +2606,7 @@ var renderCountFilesLines = ({ args }) => {
   } catch (e) {
     directoryPath = "Error parsing arguments";
   }
-  const finalDirectoryName = path8.basename(directoryPath);
+  const finalDirectoryName = path9.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 " }),
@@ -2148,7 +2630,7 @@ var renderReadFileLines2 = ({ args }) => {
   } catch (e) {
     filepath = "Error parsing arguments";
   }
-  const finalFileName = path8.basename(filepath);
+  const finalFileName = path9.basename(filepath);
   return (
     // A caixa externa com a borda, seguindo o template
     /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
@@ -2186,20 +2668,13 @@ 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__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
-          /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u{1F9E0} " }),
-          "Thinking Process"
-        ] }) }),
-        /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
-          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Thought:" }),
+        /* @__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__ */ jsxs8(Text8, { children: [
-            /* @__PURE__ */ jsx8(Text8, { color: "gray", children: "\u21B3 " }),
-            /* @__PURE__ */ jsx8(Text8, { color: task.startsWith("\u{1F5F8}") ? "green" : "yellow", children: task })
-          ] }) }, index))
+          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))
         ] })
       ] })
     );
@@ -2218,7 +2693,7 @@ var renderEditToolCall = ({ args, preview }) => {
   } catch (e) {
     filepath = "Error parsing arguments";
   }
-  const finalFileName = path8.basename(filepath);
+  const finalFileName = path9.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 " }),
@@ -2250,7 +2725,7 @@ var renderGenericToolCall = ({ toolName, args }) => {
 var ToolRenderDisplay = {
   "shell_command": renderShellCommand2,
   "ls_tool": renderLsTool2,
-  "sequentialThinking_nootebook": renderBlumaNotebook,
+  "reasoning_nootebook": renderBlumaNotebook,
   "count_file_lines": renderCountFilesLines,
   "read_file_lines": renderReadFileLines2,
   "edit_tool": renderEditToolCall
@@ -2292,42 +2767,51 @@ var ToolResultDisplay = memo3(ToolResultDisplayComponent);
 import { Box as Box11, Text as Text10 } from "ink";
 import Spinner from "ink-spinner";
 import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
-var SessionInfoConnectingMCP = ({ sessionId: sessionId2, workdir, statusMessage }) => {
-  return /* @__PURE__ */ jsxs9(
+var SessionInfoConnectingMCP = ({
+  sessionId: sessionId2,
+  workdir,
+  statusMessage
+}) => {
+  return /* @__PURE__ */ jsx11(
     Box11,
     {
       borderStyle: "round",
       borderColor: "gray",
-      flexDirection: "column",
       marginBottom: 1,
-      padding: 1,
-      children: [
-        /* @__PURE__ */ jsxs9(Text10, { children: [
-          /* @__PURE__ */ jsx11(Text10, { bold: true, color: "white", children: "localhost" }),
-          " ",
-          /* @__PURE__ */ jsx11(Text10, { color: "gray", children: " session:" }),
-          " ",
-          /* @__PURE__ */ jsx11(Text10, { color: "magenta", children: sessionId2 })
-        ] }),
-        /* @__PURE__ */ jsxs9(Text10, { children: [
-          /* @__PURE__ */ jsx11(Text10, { color: "magenta", children: "\u21B3" }),
-          " ",
-          /* @__PURE__ */ jsxs9(Text10, { color: "gray", children: [
-            "workdir: ",
-            workdir
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs9(Text10, { children: [
-          /* @__PURE__ */ jsx11(Text10, { color: "magenta", children: "\u21B3" }),
-          " ",
-          /* @__PURE__ */ jsx11(Text10, { color: "gray", children: "mcp: " }),
-          /* @__PURE__ */ jsxs9(Text10, { color: "yellow", children: [
-            /* @__PURE__ */ jsx11(Spinner, { type: "dots" }),
-            " "
-          ] }),
-          /* @__PURE__ */ jsx11(Text10, { color: "white", children: statusMessage || "Please wait while we establish connections." })
-        ] })
-      ]
+      children: /* @__PURE__ */ jsxs9(
+        Box11,
+        {
+          marginLeft: 1,
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsxs9(Text10, { children: [
+              /* @__PURE__ */ jsx11(Text10, { bold: true, color: "white", children: "localhost" }),
+              " ",
+              /* @__PURE__ */ jsx11(Text10, { color: "gray", children: " session:" }),
+              " ",
+              /* @__PURE__ */ jsx11(Text10, { color: "magenta", children: sessionId2 })
+            ] }),
+            /* @__PURE__ */ jsxs9(Text10, { children: [
+              /* @__PURE__ */ jsx11(Text10, { color: "magenta", children: "\u21B3" }),
+              " ",
+              /* @__PURE__ */ jsxs9(Text10, { color: "gray", children: [
+                "workdir: ",
+                workdir
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs9(Text10, { children: [
+              /* @__PURE__ */ jsx11(Text10, { color: "magenta", children: "\u21B3" }),
+              " ",
+              /* @__PURE__ */ jsx11(Text10, { color: "gray", children: "mcp: " }),
+              /* @__PURE__ */ jsxs9(Text10, { color: "yellow", children: [
+                /* @__PURE__ */ jsx11(Spinner, { type: "dots" }),
+                " "
+              ] }),
+              /* @__PURE__ */ jsx11(Text10, { color: "white", children: statusMessage || "Please wait while we establish connections." })
+            ] })
+          ]
+        }
+      )
     }
   );
 };
@@ -2360,6 +2844,22 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
       setHistory((prev) => prev.filter((item) => item.id === 0 || item.id === 1));
       return outBox(/* @__PURE__ */ jsx12(Text11, { color: "green", children: "History cleared." }));
     }
+    if (cmd === "init") {
+      (async () => {
+        try {
+          await agentRef.current?.processTurn({ content: "/init" });
+        } catch (e) {
+          setHistory((prev) => prev.concat({
+            id: Date.now(),
+            component: outBox(/* @__PURE__ */ jsxs10(Text11, { color: "red", children: [
+              "Failed to execute /init: ",
+              e?.message || String(e)
+            ] }))
+          }));
+        }
+      })();
+      return null;
+    }
     if (cmd === "mcp") {
       const all = agentRef.current?.getUiToolsDetailed?.() || agentRef.current?.getAvailableTools?.() || [];
       const isMcp = (t) => t.source?.toLowerCase?.() === "mcp" || !!t.server && t.server !== "native";
@@ -2471,12 +2971,12 @@ var SlashCommands_default = SlashCommands;
 import updateNotifier from "update-notifier";
 import { readPackageUp } from "read-package-up";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import path9 from "path";
+import path10 from "path";
 import fs8 from "fs";
 function findPackageJsonNearest(startDir) {
   let dir = startDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = path9.join(dir, "package.json");
+    const candidate = path10.join(dir, "package.json");
     if (fs8.existsSync(candidate)) {
       try {
         const raw = fs8.readFileSync(candidate, "utf8");
@@ -2485,7 +2985,7 @@ function findPackageJsonNearest(startDir) {
       } catch {
       }
     }
-    const parent = path9.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -2499,14 +2999,14 @@ async function checkForUpdates() {
     const binPath = process.argv?.[1];
     let pkg;
     if (binPath && fs8.existsSync(binPath)) {
-      const candidatePkg = findPackageJsonNearest(path9.dirname(binPath));
+      const candidatePkg = findPackageJsonNearest(path10.dirname(binPath));
       if (candidatePkg?.name && candidatePkg?.version) {
         pkg = candidatePkg;
       }
     }
     if (!pkg) {
       const __filename = fileURLToPath3(import.meta.url);
-      const __dirname = path9.dirname(__filename);
+      const __dirname = path10.dirname(__filename);
       const result = await readPackageUp({ cwd: __dirname });
       pkg = result?.packageJson;
     }
@@ -2607,6 +3107,7 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
           setIsProcessing(false);
           return;
         }
+        setIsProcessing(true);
         setHistory((prev) => [
           ...prev,
           {
@@ -2615,10 +3116,16 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
           },
           {
             id: prev.length + 1,
-            component: /* @__PURE__ */ jsx14(SlashCommands_default, { input: text, setHistory, agentRef: agentInstance })
+            component: /* @__PURE__ */ jsx14(
+              SlashCommands_default,
+              {
+                input: text,
+                setHistory,
+                agentRef: agentInstance
+              }
+            )
           }
         ]);
-        setIsProcessing(false);
         return;
       }
       setIsProcessing(true);
@@ -2830,21 +3337,14 @@ var AppComponent = ({ eventBus: eventBus2, sessionId: sessionId2 }) => {
   }, [eventBus2, sessionId2, handleConfirmation]);
   const renderInteractiveComponent = () => {
     if (mcpStatus !== "connected") {
-      return /* @__PURE__ */ jsx14(
-        Box14,
+      return /* @__PURE__ */ jsx14(Box14, { borderStyle: "round", borderColor: "black", children: /* @__PURE__ */ jsx14(
+        SessionInfoConnectingMCP_default,
         {
-          borderStyle: "round",
-          borderColor: "black",
-          children: /* @__PURE__ */ jsx14(
-            SessionInfoConnectingMCP_default,
-            {
-              sessionId: sessionId2,
-              workdir,
-              statusMessage
-            }
-          )
+          sessionId: sessionId2,
+          workdir,
+          statusMessage
         }
-      );
+      ) });
     }
     if (pendingConfirmation) {
       return /* @__PURE__ */ jsx14(