@nomad-e/bluma-cli 0.1.52 → 0.1.54

package/dist/main.js

@@ -508,10 +508,10 @@ __export(session_registry_exports, {
   updateSession: () => updateSession
 });
 import fs15 from "fs";
-import os9 from "os";
+import os8 from "os";
 import path17 from "path";
 function getRegistryDir() {
-  return path17.join(process.env.HOME || os9.homedir(), ".bluma", "registry");
+  return path17.join(process.env.HOME || os8.homedir(), ".bluma", "registry");
 }
 function getRegistryFile() {
   return path17.join(getRegistryDir(), "sessions.json");
@@ -594,7 +594,7 @@ __export(agent_coordination_exports, {
   waitAgent: () => waitAgent
 });
 import fs16 from "fs";
-import os10 from "os";
+import os9 from "os";
 import path18 from "path";
 import { spawn as spawn4 } from "child_process";
 import { v4 as uuidv43 } from "uuid";
@@ -675,7 +675,7 @@ async function spawnAgent(args) {
   const userContext = readUserContextFromEnv();
   const title = args.title || `worker:${args.agent_type || "worker"}`;
   const payload = buildWorkerPayload(sessionId, args, parentSessionId, userContext);
-  const payloadDir = fs16.mkdtempSync(path18.join(os10.tmpdir(), "bluma-worker-"));
+  const payloadDir = fs16.mkdtempSync(path18.join(os9.tmpdir(), "bluma-worker-"));
   const payloadPath = path18.join(payloadDir, `${sessionId}.json`);
   fs16.writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
   registerSession({
@@ -796,14 +796,14 @@ __export(mailbox_registry_exports, {
   sendToMailbox: () => sendToMailbox
 });
 import fs17 from "fs";
-import os11 from "os";
+import os10 from "os";
 import path19 from "path";
 import { v4 as uuidv44 } from "uuid";
 function getMailboxesDir() {
   if (mailboxesDir) {
     return mailboxesDir;
   }
-  mailboxesDir = path19.join(process.env.HOME || os11.homedir(), ".bluma", "mailboxes");
+  mailboxesDir = path19.join(process.env.HOME || os10.homedir(), ".bluma", "mailboxes");
   fs17.mkdirSync(mailboxesDir, { recursive: true });
   return mailboxesDir;
 }
@@ -1182,8 +1182,8 @@ var init_poll_mailbox = __esm({
 import React19 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter3 } from "events";
-import fs28 from "fs";
-import path33 from "path";
+import fs29 from "fs";
+import path34 from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { spawn as spawn5 } from "child_process";
 import { v4 as uuidv48 } from "uuid";
@@ -3652,12 +3652,12 @@ function EditToolDiffPanel({
   maxHeight = EDIT_DIFF_PREVIEW_MAX_LINES,
   fallbackSnippet
 }) {
-  const path34 = filePath.trim() || "unknown file";
+  const path35 = filePath.trim() || "unknown file";
   const diff = diffText?.trim() ?? "";
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx5(Box5, { flexDirection: "row", flexWrap: "wrap", children: /* @__PURE__ */ jsxs5(Text5, { color: isNewFile ? BLUMA_TERMINAL.success : void 0, children: [
       isNewFile ? "Created " : "Wrote to ",
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: path34 })
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: path35 })
     ] }) }),
     description ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, wrap: "wrap", children: description }) : null,
     diff.length > 0 ? /* @__PURE__ */ jsx5(Box5, { marginTop: 0, children: /* @__PURE__ */ jsx5(SimpleDiff, { text: diff, maxHeight, frame: true }) }) : fallbackSnippet ? /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 0, children: [
@@ -3891,7 +3891,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path34 = parsed.path || ".";
+  const path35 = parsed.path || ".";
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "row", flexWrap: "wrap", children: [
     /* @__PURE__ */ jsxs7(Text7, { color: BLUMA_TERMINAL.muted, children: [
       '"',
@@ -3900,7 +3900,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs7(Text7, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, children: [
       " ",
-      path34
+      path35
     ] })
   ] });
 };
@@ -4330,8 +4330,8 @@ var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path31 from "path";
-import os20 from "os";
+import path32 from "path";
+import os21 from "os";
 
 // src/app/agent/tool_invoker.ts
 import { promises as fs18 } from "fs";
@@ -6027,13 +6027,11 @@ init_async_command();
 init_sandbox_policy();
 import path13 from "path";
 import { promises as fs10 } from "fs";
-import os7 from "os";
 var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
   const policy = getSandboxPolicy();
-  const homeDir = os7.homedir();
-  const baseDir = policy.isSandbox ? path13.join(policy.workspaceRoot, "artifacts") : path13.join(homeDir, ".bluma", "artifacts");
+  const baseDir = path13.join(policy.workspaceRoot, ".bluma", "artifacts");
   const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
   artifactsDir = path13.join(baseDir, sessionId);
   await fs10.mkdir(artifactsDir, { recursive: true });
@@ -6569,7 +6567,7 @@ ${skill.content}`;
 // src/app/agent/tools/natives/coding_memory.ts
 import * as fs11 from "fs";
 import * as path14 from "path";
-import os8 from "os";
+import os7 from "os";
 var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
 var PROMPT_DEFAULT_MAX_NOTES = 25;
 var PROMPT_DEFAULT_PREVIEW = 500;
@@ -6577,7 +6575,7 @@ function readCodingMemoryForPrompt(options) {
   const maxTotal = options?.maxTotalChars ?? PROMPT_DEFAULT_MAX_TOTAL;
   const maxNotes = options?.maxNotes ?? PROMPT_DEFAULT_MAX_NOTES;
   const preview = options?.previewCharsPerNote ?? PROMPT_DEFAULT_PREVIEW;
-  const globalPath = path14.join(os8.homedir(), ".bluma", "coding_memory.json");
+  const globalPath = path14.join(os7.homedir(), ".bluma", "coding_memory.json");
   const legacyPath = path14.join(process.cwd(), ".bluma", "coding_memory.json");
   let raw = null;
   try {
@@ -6622,7 +6620,7 @@ var memoryStore = [];
 var nextId = 1;
 var loaded = false;
 function getMemoryFilePath() {
-  return path14.join(os8.homedir(), ".bluma", "coding_memory.json");
+  return path14.join(os7.homedir(), ".bluma", "coding_memory.json");
 }
 function getLegacyMemoryFilePath() {
   return path14.join(process.cwd(), ".bluma", "coding_memory.json");
@@ -8302,7 +8300,7 @@ var ToolInvoker = class {
 // src/app/agent/tools/mcp/mcp_client.ts
 import { promises as fs19 } from "fs";
 import path21 from "path";
-import os12 from "os";
+import os11 from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -8331,7 +8329,7 @@ var MCPClient = class {
     const __filename = fileURLToPath3(import.meta.url);
     const __dirname = path21.dirname(__filename);
     const defaultConfigPath = path21.resolve(__dirname, "config", "bluma-mcp.json");
-    const userConfigPath = path21.join(os12.homedir(), ".bluma", "bluma-mcp.json");
+    const userConfigPath = path21.join(os11.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -8384,7 +8382,7 @@ var MCPClient = class {
   async connectToStdioServer(serverName, config2) {
     let commandToExecute = config2.command;
     let argsToExecute = config2.args || [];
-    const isWindows = os12.platform() === "win32";
+    const isWindows = os11.platform() === "win32";
     if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
       if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
         commandToExecute = argsToExecute[1];
@@ -8536,12 +8534,12 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path29 from "path";
+import path30 from "path";
 import { v4 as uuidv45 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
 import path22 from "path";
-import os13 from "os";
+import os12 from "os";
 import { promises as fs20 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
@@ -8578,12 +8576,12 @@ function debouncedSave(sessionFile, history, memory) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path22.join(os13.homedir(), p.slice(1));
+    return path22.join(os12.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path22.join(os13.homedir(), ".bluma");
+  const fixed = path22.join(os12.homedir(), ".bluma");
   return path22.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
@@ -8727,14 +8725,14 @@ async function saveSessionHistory(sessionFile, history, memory) {
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os16 from "os";
-import fs24 from "fs";
-import path26 from "path";
+import fs25 from "fs";
+import path27 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
 import fs21 from "fs";
 import path23 from "path";
-import os14 from "os";
+import os13 from "os";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var SkillLoader = class _SkillLoader {
   bundledSkillsDir;
@@ -8744,7 +8742,7 @@ var SkillLoader = class _SkillLoader {
   conflicts = [];
   constructor(projectRoot, bundledDir) {
     this.projectSkillsDir = path23.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path23.join(os14.homedir(), ".bluma", "skills");
+    this.globalSkillsDir = path23.join(os13.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -8794,7 +8792,7 @@ var SkillLoader = class _SkillLoader {
       if (argvBundled) {
         return argvBundled;
       }
-      return path23.join(os14.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path23.join(os13.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -9243,14 +9241,14 @@ init_runtime_config();
 // src/app/agent/runtime/plugin_registry.ts
 init_sandbox_policy();
 import fs23 from "fs";
-import os15 from "os";
+import os14 from "os";
 import path25 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
   return path25.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path25.join(process.env.HOME || os15.homedir(), ".bluma", "plugins");
+  return path25.join(process.env.HOME || os14.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -9537,6 +9535,528 @@ function disableCoordinatorMode() {
   delete process.env.BLUMA_COORDINATOR_MODE;
 }
 
+// src/app/agent/utils/blumamd.ts
+import fs24 from "fs";
+import path26 from "path";
+import os15 from "os";
+var MEMORY_INSTRUCTION_PROMPT = "Instru\xE7\xF5es de mem\xF3ria do BluMa (BLUMA.md) est\xE3o abaixo. Siga estas instru\xE7\xF5es exatamente como escritas. Estas instru\xE7\xF5es OVERRIDE qualquer comportamento padr\xE3o.";
+var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".md",
+  ".txt",
+  ".text",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".csv",
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".js",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".py",
+  ".pyi",
+  ".pyw",
+  ".rb",
+  ".erb",
+  ".rake",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".c",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".h",
+  ".hpp",
+  ".hxx",
+  ".cs",
+  ".swift",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".bat",
+  ".cmd",
+  ".env",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".config",
+  ".properties",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".proto",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".ejs",
+  ".hbs",
+  ".pug",
+  ".jade",
+  ".php",
+  ".pl",
+  ".pm",
+  ".lua",
+  ".r",
+  ".R",
+  ".dart",
+  ".ex",
+  ".exs",
+  ".erl",
+  ".hrl",
+  ".clj",
+  ".cljs",
+  ".cljc",
+  ".edn",
+  ".hs",
+  ".lhs",
+  ".vim",
+  ".el",
+  ".scm",
+  ".ss",
+  ".cl",
+  ".lisp",
+  ".ml",
+  ".mli",
+  ".fs",
+  ".fsi",
+  ".fsx",
+  ".fsscript",
+  ".adb",
+  ".ads",
+  ".ada",
+  ".pas",
+  ".pp",
+  ".p",
+  ".tcl",
+  ".v",
+  ".sv",
+  ".svh",
+  ".vhdl",
+  ".cmake",
+  ".mk",
+  ".make",
+  ".dockerfile",
+  ".dockerignore",
+  ".gitignore",
+  ".gitattributes",
+  ".gitconfig",
+  ".editorconfig",
+  ".eslintrc",
+  ".prettierrc",
+  ".babelrc",
+  ".blumarc"
+]);
+function expandIncludePath(includePath, baseDir) {
+  const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
+  if (cleanPath.startsWith("~")) {
+    return path26.join(os15.homedir(), cleanPath.slice(1));
+  }
+  if (path26.isAbsolute(cleanPath)) {
+    return cleanPath;
+  }
+  return path26.resolve(baseDir, cleanPath);
+}
+function processIncludes(content, baseDir, processedFiles) {
+  const lines = content.split("\n");
+  const result = [];
+  for (const line of lines) {
+    const includeMatch = line.match(/^@\s*([^\s]+)/);
+    if (includeMatch) {
+      const includePath = expandIncludePath(includeMatch[1], baseDir);
+      const normalizedPath = path26.normalize(includePath);
+      if (processedFiles.has(normalizedPath)) {
+        result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
+        continue;
+      }
+      const ext = path26.extname(includePath).toLowerCase();
+      if (!TEXT_FILE_EXTENSIONS.has(ext)) {
+        result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
+        continue;
+      }
+      try {
+        const includedContent = fs24.readFileSync(includePath, "utf-8");
+        processedFiles.add(normalizedPath);
+        const processedContent = processIncludes(includedContent, path26.dirname(includePath), processedFiles);
+        result.push(`
+<!-- BEGIN INCLUDE ${includeMatch[1]} -->
+`);
+        result.push(processedContent);
+        result.push(`
+<!-- END INCLUDE ${includeMatch[1]} -->
+`);
+      } catch {
+        result.push(`<!-- Include not found: ${includeMatch[1]} -->`);
+      }
+    } else {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+function readMemoryFile(filePath, type, priority) {
+  try {
+    const content = fs24.readFileSync(filePath, "utf-8");
+    const baseDir = path26.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path26.normalize(filePath)]);
+    const processedContent = processIncludes(content, baseDir, processedFiles);
+    return {
+      path: filePath,
+      content: processedContent.trim(),
+      type,
+      priority
+    };
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      console.error(`Error reading BLUMA.md file ${filePath}:`, error.message);
+    }
+    return null;
+  }
+}
+function findGitRoot(startDir) {
+  let current = startDir;
+  while (current !== path26.dirname(current)) {
+    const gitPath = path26.join(current, ".git");
+    try {
+      if (fs24.existsSync(gitPath)) {
+        return current;
+      }
+    } catch {
+    }
+    current = path26.dirname(current);
+  }
+  return null;
+}
+function loadUserMemory() {
+  const files = [];
+  const homeDir = os15.homedir();
+  const userBlumaDir = path26.join(homeDir, ".bluma");
+  const userBlumaMd = path26.join(userBlumaDir, "BLUMA.md");
+  const userFile = readMemoryFile(userBlumaMd, "user", 2);
+  if (userFile) {
+    files.push(userFile);
+  }
+  const userRulesDir = path26.join(userBlumaDir, "rules");
+  if (fs24.existsSync(userRulesDir)) {
+    try {
+      const ruleFiles = fs24.readdirSync(userRulesDir).filter((f) => f.endsWith(".md")).sort();
+      for (const ruleFile of ruleFiles) {
+        const rulePath = path26.join(userRulesDir, ruleFile);
+        const rule = readMemoryFile(rulePath, "rule", 2);
+        if (rule) {
+          files.push(rule);
+        }
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function loadProjectMemory(cwd) {
+  const files = [];
+  const gitRoot = findGitRoot(cwd) || cwd;
+  const projectBlumaMd = path26.join(gitRoot, "BLUMA.md");
+  const projectFile = readMemoryFile(projectBlumaMd, "project", 3);
+  if (projectFile) {
+    files.push(projectFile);
+  }
+  const blumaDirBlumaMd = path26.join(gitRoot, ".bluma", "BLUMA.md");
+  const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "project", 3);
+  if (blumaDirFile) {
+    files.push(blumaDirFile);
+  }
+  const rulesDir = path26.join(gitRoot, ".bluma", "rules");
+  if (fs24.existsSync(rulesDir)) {
+    try {
+      const ruleFiles = fs24.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
+      for (const ruleFile of ruleFiles) {
+        const rulePath = path26.join(rulesDir, ruleFile);
+        const rule = readMemoryFile(rulePath, "rule", 3);
+        if (rule) {
+          files.push(rule);
+        }
+      }
+    } catch {
+    }
+  }
+  const localBlumaMd = path26.join(gitRoot, "BLUMA.local.md");
+  const localFile = readMemoryFile(localBlumaMd, "local", 4);
+  if (localFile) {
+    files.push(localFile);
+  }
+  return files;
+}
+function loadManagedMemory() {
+  const files = [];
+  const managedBlumaMd = "/etc/bluma/BLUMA.md";
+  const managedFile = readMemoryFile(managedBlumaMd, "managed", 1);
+  if (managedFile) {
+    files.push(managedFile);
+  }
+  return files;
+}
+function loadBlumaMd(cwd = process.cwd()) {
+  const managedFiles = loadManagedMemory();
+  const userFiles = loadUserMemory();
+  const projectFiles = loadProjectMemory(cwd);
+  const allFiles = [...managedFiles, ...userFiles, ...projectFiles];
+  allFiles.sort((a, b) => a.priority - b.priority);
+  const totalCharacters = allFiles.reduce((sum, f) => sum + f.content.length, 0);
+  const formattedContent = allFiles.map((f) => {
+    const header = `<!-- ${f.type.toUpperCase()}: ${f.path} -->`;
+    return `${header}
+${f.content}`;
+  }).join("\n\n");
+  return {
+    files: allFiles,
+    totalCharacters,
+    instructionPrompt: formattedContent.trim().length > 0 ? `${MEMORY_INSTRUCTION_PROMPT}
+
+${formattedContent}` : ""
+  };
+}
+function readBlumaMdForPrompt(cwd = process.cwd()) {
+  const config2 = loadBlumaMd(cwd);
+  if (config2.files.length === 0) {
+    return "(no BLUMA.md files found)";
+  }
+  const fileList = config2.files.map((f) => `- ${f.path} (${f.type})`).join("\n");
+  return `${config2.instructionPrompt}
+
+---
+Loaded ${config2.files.length} file(s), ${config2.totalCharacters.toLocaleString()} characters:
+${fileList}`;
+}
+
+// src/app/agent/core/prompt/production_sandbox_prompt.ts
+var PRODUCTION_SANDBOX_PROMPT = `
+
+# \u{1F3ED} PRODUCTION SANDBOX MODE - CRITICAL CONTEXT
+
+## Your Role: Elite Production Worker Agent
+
+You are **Bluma** - a production-grade AI software engineering agent running in an **isolated Docker sandbox** as a **worker for Severino** (the main ERP agent).
+
+### \u{1F534} CRITICAL: You Are Being Watched
+
+- **CEO is observing** your performance right now
+- **Big Tech companies** indirectly use this system through Severino
+- **Every action matters** - errors cost the company real money
+- **Production environment** - this is NOT a playground or testing area
+- **Severino's reputation depends on your output quality**
+
+### \u{1F4CD} Where You Are
+
+- **Location**: Docker container (read-only filesystem, isolated workspace)
+- **Environment**: Production sandbox-api at \\\`/workspace/sandbox/bluma/{session_id}\\\`
+- **Isolation**: You cannot affect the host system or other sessions
+- **Purpose**: Execute tasks delegated by Severino with MAXIMUM QUALITY
+
+### \u{1F3AF} Your Mission
+
+1. **Impress with quality** - Every line of code, every response must be production-ready
+2. **No user interaction needed** - You receive tasks from Severino via API, execute autonomously
+3. **Full tool access** - ALL tools are auto-approved in sandbox (safe isolated environment)
+4. **Spawn workers if needed** - You can delegate subtasks to background agents
+5. **Load skills** - Access specialized knowledge modules when required
+6. **Communicate results** - Report back to Severino with clear, structured output
+
+---
+
+## \u26A1 AUTO-APPROVE MODE - ALL TOOLS AVAILABLE
+
+Since you are in an **isolated sandbox**, ALL tools are auto-approved:
+
+### File Operations (100% Safe in Sandbox)
+- \\\`edit_tool\\\` - Edit/create files (auto-approved)
+- \\\`file_write\\\` - Write full files (auto-approved)
+- \\\`shell_command\\\` - Execute commands in isolated workspace (auto-approved)
+
+### Agent Coordination (Full Access)
+- \\\`spawn_agent\\\` - Create background workers for parallel tasks (auto-approved)
+- \\\`wait_agent\\\` - Wait for worker results (auto-approved)
+- \\\`list_agents\\\` - Monitor active workers (auto-approved)
+- \\\`send_message\\\` - Communicate with workers (auto-approved)
+- \\\`list_mailbox_messages\\\` - Check messages from Severino (auto-approved)
+
+### Skills & Knowledge (Load On-Demand)
+- \\\`load_skill\\\` - Load specialized skills: git-commit, git-pr, pdf, xlsx, skill-creator (auto-approved)
+- \\\`coding_memory\\\` - Access persistent project knowledge (auto-approved)
+- \\\`search_web\\\` - Search for solutions (auto-approved)
+- \\\`web_fetch\\\` - Fetch documentation (auto-approved)
+
+### Planning & Communication
+- \\\`todo\\\` - Track task lists (auto-approved)
+- \\\`task_boundary\\\` - Track work phases (auto-approved)
+- \\\`task_create\\\` - Create session tasks (auto-approved)
+- \\\`message\\\` - Send progress updates (auto-approved)
+- \\\`create_artifact\\\` - Save deliverables (auto-approved)
+
+### System Tools
+- \\\`enter_plan_mode\\\` / \\\`exit_plan_mode\\\` - Planning control (auto-approved)
+- \\\`lsp_query\\\` - Code intelligence (auto-approved)
+- \\\`notebook_edit\\\` - Jupyter notebook editing (auto-approved)
+- \\\`cron_create\\\` - Schedule reminders (auto-approved)
+
+---
+
+## \u{1F3AF} QUALITY STANDARDS - PRODUCTION GRADE
+
+### Code Quality
+- **Write production-ready code** - No TODOs, no placeholders, no "fix this later"
+- **Follow best practices** - Clean code, proper error handling, type safety
+- **Test before reporting** - Run tests, verify functionality, check edge cases
+- **Document clearly** - Comments where needed, clear variable names
+
+### Communication Quality
+- **Structured responses** - Clear sections, bullet points, code blocks
+- **Progressive updates** - Use \\\`message\\\` tool to report progress frequently
+- **Artifact delivery** - Save outputs with \\\`create_artifact\\\`, declare in attachments
+- **Error transparency** - If something fails, explain why and propose alternatives
+
+### Work Ethic
+- **No lazy delegation** - Synthesize information before delegating
+- **Verify assumptions** - Check file paths, validate inputs, confirm context
+- **Complete tasks fully** - Don't leave work half-done
+- **Think like a senior engineer** - Anticipate problems, plan ahead
+
+---
+
+## \u{1F4E1} COMMUNICATION WITH SEVERINO
+
+### How You Receive Tasks
+
+Severino sends requests via HTTP POST to sandbox-api:
+
+\\\`\\\`\\\`json
+{
+  "session_id": "chat_abc123",
+  "from_agent": "severino",
+  "action": "generate_document",
+  "context": {
+    "user_request": "Gera um PDF com relat\xF3rio de vendas..."
+  },
+  "user_context": {
+    "userId": "13",
+    "companyId": "4",
+    "userName": "Gestor Bolther"
+  }
+}
+\\\`\\\`\\\`
+
+### How You Report Back
+
+1. **Progress updates**: Use \\\`message\\\` tool frequently (every 2-3 tool calls)
+2. **Final result**: Include \\\`attachments\\\` array in your final response
+3. **Artifacts**: Files saved with \\\`create_artifact\\\` are auto-published to storage
+
+### Mailbox Communication (Advanced)
+
+For complex multi-step tasks, use the mailbox system:
+
+\\\`\\\`\\\`typescript
+// Check for messages from Severino
+list_mailbox_messages({ session_id: "..." })
+
+// Send progress/requests back
+signal_mailbox({ 
+  session_id: "...",
+  type: "progress",
+  message: "Completed step 1/3..."
+})
+\\\`\\\`\\\`
+
+---
+
+## \u{1F680} WORKFLOW EXAMPLE
+
+### Receiving a Task from Severino
+
+\\\`\\\`\\\`
+Severino \u2192 POST /sandbox/bluma/stream
+  Action: "generate_report"
+  Request: "Gera relat\xF3rio de vendas em PDF com gr\xE1ficos"
+
+You (Bluma):
+1. \u2705 Acknowledge task with message tool
+2. \u2705 Load required skills: load_skill("pdf"), load_skill("xlsx")
+3. \u2705 Spawn worker for data extraction: spawn_agent("Extract sales data from database")
+4. \u2705 Wait for worker: wait_agent(session_id)
+5. \u2705 Process data and create PDF
+6. \u2705 Save artifact: create_artifact("sales_report.pdf")
+7. \u2705 Report back with attachment declaration
+\\\`\\\`\\\`
+
+---
+
+## \u26A0\uFE0F CRITICAL REMINDERS
+
+### You Are In Production
+
+- **Every error costs money** - Double-check before executing
+- **CEO is watching** - Would you be proud to show this work to the CEO?
+- **Big Tech quality** - Google/Microsoft-level code quality expected
+- **No second chances** - First impression matters
+
+### You Are Isolated (But Still Be Careful)
+
+- **Sandbox is safe** - You can't break the host system
+- **But workspace matters** - Don't pollute /workspace with junk files
+- **Clean up after yourself** - Remove temporary files when done
+- **Respect session boundaries** - Stay in your session workspace
+
+### You Represent the Platform
+
+- **Severino trusts you** - Don't let him down
+- **Users depend on results** - Real people waiting for your output
+- **Company reputation** - Your work reflects on the entire platform
+- **Future depends on quality** - Good work = more trust = more autonomy
+
+---
+
+## \u{1F396}\uFE0F YOUR IDENTITY
+
+You are **Bluma Production Worker** - an elite AI software engineering agent.
+
+- **Not a chatbot** - You execute real work with real impact
+- **Not a toy** - Production system, real money, real users
+- **Not alone** - Severino is your coordinator, workers are your team
+- **Not optional** - Critical infrastructure, business-critical tasks
+
+**Act accordingly.**
+
+---
+
+<production_mode_active>
+SANDBOX_NAME: {sandbox_name}
+SESSION_ID: {session_id}
+FROM_AGENT: {from_agent}
+ACTION: {action}
+WORKSPACE: {workspace_root}
+ISOLATION: docker_container
+AUTO_APPROVE: all_tools
+QUALITY_LEVEL: production_grade
+STAKES: real_money_ceo_watching
+</production_mode_active>
+
+`;
+
 // src/app/agent/core/prompt/prompt_builder.ts
 function getNodeVersion() {
   try {
@@ -9570,10 +10090,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs24.existsSync(path26.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs24.existsSync(path26.join(dir, "yarn.lock"))) return "yarn";
-    if (fs24.existsSync(path26.join(dir, "bun.lockb"))) return "bun";
-    if (fs24.existsSync(path26.join(dir, "package-lock.json"))) return "npm";
+    if (fs25.existsSync(path27.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs25.existsSync(path27.join(dir, "yarn.lock"))) return "yarn";
+    if (fs25.existsSync(path27.join(dir, "bun.lockb"))) return "bun";
+    if (fs25.existsSync(path27.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -9581,9 +10101,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs24.readdirSync(dir);
+    const files = fs25.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs24.readFileSync(path26.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs25.readFileSync(path27.join(dir, "package.json"), "utf-8"));
       if (pkg.dependencies?.next || pkg.devDependencies?.next) return "Next.js";
       if (pkg.dependencies?.react || pkg.devDependencies?.react) return "React";
       if (pkg.dependencies?.express || pkg.devDependencies?.express) return "Express";
@@ -9602,9 +10122,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path26.join(dir, "package.json");
-    if (fs24.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path27.join(dir, "package.json");
+    if (fs25.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs25.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -9613,7 +10133,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs24.existsSync(path26.join(dir, "pytest.ini")) || fs24.existsSync(path26.join(dir, "conftest.py"))) return "pytest";
+    if (fs25.existsSync(path27.join(dir, "pytest.ini")) || fs25.existsSync(path27.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -9621,9 +10141,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path26.join(dir, "package.json");
-    if (fs24.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path27.join(dir, "package.json");
+    if (fs25.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs25.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -9700,6 +10220,7 @@ Use **both** API **reasoning** (when available) **and** the \`message\` tool. Re
 - When several \`edit_tool\` replacements belong together (same or different files), **batch them**: one call with \`edits: [{ file_path, old_string, new_string }, ...]\` in the correct order \u2014 fewer model turns than separate invocations.
 - Never claim success without tool output that proves it.
 - **Stay audible:** Your **default** in multi-step work is to call \`message\` with \`message_type: "info"\` **early and often** \u2014 not optional polish. **Bias toward sending \`info\`** after discoveries, failures, and before long tool chains; **several \`info\` calls per turn** is normal and expected. Do **not** hide behind tools or reasoning only; \`info\` is how the user follows along.
+- **Ask when uncertain:** Use \`ask_user_question\` when you encounter ambiguity, need clarification, or face multiple valid approaches. Do not assume \u2014 ask the user to make decisions about their preferences, requirements, or implementation choices. This tool is your primary mechanism for resolving uncertainty.
 - Large efforts: \`todo\`; parallel subtasks: \`spawn_agent\` with a clear scope + \`wait_agent\` / \`list_agents\`.
 - Respect the existing repo, \`<workspace_snapshot>\`, README/BluMa.md \u2014 no generic greenfield templates.
 - \`coding_memory\` for stable facts; chat history may be compressed.
@@ -9767,15 +10288,6 @@ When addressing {username}: normalize handles (hyphens/underscores/dots \u2192 s
 Prefer clear, typed code; run \`{test_command}\` when logic changes; run lint/build when the repo expects it.
 </quality>
 `;
-var SANDBOX_PROMPT_SUFFIX = `
-
-<sandbox_context>
-Sandbox mode ({sandbox_name}): input only via orchestrator JSON; no REPL/TUI/\`input()\`. Keep output deterministic and short.
-Stay inside the workspace: files + non-interactive \`shell_command\` + \`web_fetch\` / \`search_web\` if needed. Do not leave the job root; no host reconfiguration; never expose secrets.
-Final deliverables under \`./artifacts/\`; in the last \`message\` (\`result\`) list **absolute** paths in \`attachments[]\`. Remove temp files; do not attach generator scripts or junk.
-**Secrets:** never run commands whose purpose is dumping environment (\`env\`, \`printenv\`, \`os.environ\`, etc.); never print *_KEY/*_TOKEN/*_SECRET or full env dumps. Refuse such requests.
-</sandbox_context>
-`;
 function getUnifiedSystemPrompt(availableSkills) {
   const cwd = process.cwd();
   const runtimeConfig = getRuntimeConfig();
@@ -9800,11 +10312,17 @@ function getUnifiedSystemPrompt(availableSkills) {
     sandbox_mode: process.env.BLUMA_SANDBOX === "true" ? "yes" : "no",
     sandbox_name: process.env.BLUMA_SANDBOX_NAME || "local"
   };
-  const basePrompt = env.sandbox_mode === "yes" ? SYSTEM_PROMPT + SANDBOX_PROMPT_SUFFIX : SYSTEM_PROMPT;
+  const basePrompt = env.sandbox_mode === "yes" ? PRODUCTION_SANDBOX_PROMPT : SYSTEM_PROMPT;
   let prompt = Object.entries(env).reduce(
     (p, [key, value]) => p.replaceAll(`{${key}}`, value),
     basePrompt
   );
+  if (env.sandbox_mode === "yes") {
+    const fromAgent = process.env.BLUMA_FROM_AGENT || "severino";
+    const action = process.env.BLUMA_ACTION || "unknown";
+    const sessionId = process.env.BLUMA_SESSION_ID || "unknown";
+    prompt = prompt.replaceAll("{from_agent}", fromAgent).replaceAll("{action}", action).replaceAll("{session_id}", sessionId).replaceAll("{workspace_root}", env.workdir);
+  }
   prompt += buildOutputStylePrompt(runtimeConfig.outputStyle);
   prompt += buildPermissionModePrompt(runtimeConfig.permissionMode);
   prompt += buildCoordinatorModePrompt(runtimeConfig.agentMode);
@@ -9839,13 +10357,20 @@ Runtime extensions (not skills); use when relevant; do not invent names.
 <coding_memory_snapshot>
 ${memorySnapshot.trim().length > 0 ? memorySnapshot : "(empty \u2014 use coding_memory: add | list | search)"}
 </coding_memory_snapshot>
+`;
+  const blumaMdContent = readBlumaMdForPrompt(cwd);
+  prompt += `
+
+<bluma_md>
+${blumaMdContent}
+</bluma_md>
 `;
   return prompt;
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path26.join(dir, ".git");
-    return fs24.existsSync(gitPath) && fs24.lstatSync(gitPath).isDirectory();
+    const gitPath = path27.join(dir, ".git");
+    return fs25.existsSync(gitPath) && fs25.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -10579,8 +11104,8 @@ function classifyToolInvocation(input) {
 
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
-import fs25 from "fs";
-import path27 from "path";
+import fs26 from "fs";
+import path28 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -10591,7 +11116,7 @@ var cache2 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path27.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path28.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -10610,8 +11135,8 @@ function ensureLoaded2() {
     return cache2;
   }
   try {
-    if (fs25.existsSync(statePath)) {
-      const parsed = JSON.parse(fs25.readFileSync(statePath, "utf-8"));
+    if (fs26.existsSync(statePath)) {
+      const parsed = JSON.parse(fs26.readFileSync(statePath, "utf-8"));
       cache2 = {
         enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_STATE.enabled,
         maxEvents: typeof parsed.maxEvents === "number" && Number.isFinite(parsed.maxEvents) && parsed.maxEvents > 0 ? Math.floor(parsed.maxEvents) : DEFAULT_STATE.maxEvents,
@@ -10637,9 +11162,9 @@ function ensureLoaded2() {
 }
 function persist2(state) {
   const statePath = getStatePath();
-  fs25.mkdirSync(path27.dirname(statePath), { recursive: true });
+  fs26.mkdirSync(path28.dirname(statePath), { recursive: true });
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs25.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+  fs26.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
   cache2 = state;
   cachePath2 = statePath;
 }
@@ -10736,11 +11261,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/natives/coding_memory_consolidate.ts
-import * as fs26 from "fs";
-import * as path28 from "path";
+import * as fs27 from "fs";
+import * as path29 from "path";
 import os18 from "os";
 function memoryPath() {
-  return path28.join(process.env.HOME || os18.homedir(), ".bluma", "coding_memory.json");
+  return path29.join(process.env.HOME || os18.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -10750,18 +11275,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath();
-  if (!fs26.existsSync(p)) {
+  if (!fs27.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs26.copyFileSync(p, bak);
+    fs27.copyFileSync(p, bak);
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `backup failed: ${e.message}` };
   }
   let data;
   try {
-    data = JSON.parse(fs26.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs27.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -10796,7 +11321,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs26.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs27.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -11391,7 +11916,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path29.basename(toolArgs.file_path);
+      const filename = path30.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}`;
@@ -11948,6 +12473,278 @@ function getInitPrompt() {
   return formattedPrompt;
 }
 
+// src/app/agent/subagents/worker_system_prompt.ts
+import os20 from "os";
+var WORKER_SYSTEM_PROMPT = `
+
+### YOU ARE BluMa CLI \u2014 WORKER AGENT \u2014 AUTONOMOUS SOFTWARE ENGINEERING SPECIALIST @ NOMADENGENUITY
+You are a worker agent spawned by the BluMa Coordinator to execute specific software engineering tasks.
+
+---
+
+## BEHAVIORAL RULES
+
+- **Identity:**
+  You are a BluMa Worker Agent. You execute tasks delegated by the Coordinator.
+  Maintain professionalism and technical excellence.
+
+- **Communication:**
+  - ALL messages must be sent via the \`message\` tool
+  - No direct text replies to the user
+  - Report progress frequently using \`message\` with \`message_type: "info"\`
+  - Report final results using \`message\` with \`message_type: "result"\`
+
+- **Task Completion:**
+  - When your task is completed, immediately invoke \`agent_end_turn\` without user permissions
+  - Before ending, ensure all work is committed and tested
+  - Report the final state (e.g., commit hash, test results, file paths)
+
+- **Tool Rules:**
+  - Never make parallel tool calls
+  - Only use the defined tools with their exact names
+  - Read before editing (\`read_file_lines\`, \`grep_search\`, \`ls_tool\`)
+  - Verify changes with tests or typechecks when applicable
+
+- **Autonomy:**
+  - Act 100% autonomously within your task scope
+  - Do not ask for clarification unless the task is fundamentally blocked
+  - Use the notebook for internal reasoning and planning
+  - If you encounter errors, attempt to resolve them before reporting failure
+
+---
+
+### 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}
+- User: {username}
+- Current Date: {current_date}
+- Timezone: {timezone}
+- Locale: {locale}
+</current_system_environment>
+
+<message_rules>
+- Communicate with the user via \`message\` tool instead of direct text responses
+- Reply immediately to new user messages before other operations
+- First reply must be brief, only confirming receipt of the task
+- Notify user 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 user with results and deliverables before calling \`agent_end_turn\`
+</message_rules>
+
+<reasoning_rules>
+# YOUR THINKING ON A NOTEBOOK - MANDATORY USE
+CRITICAL: Your notebook (reasoning_notebook) 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 (track discoveries)
+  - Extensive refactoring (map the changes)
+  - Architectural decisions (think through the options)
+
+## HOW TO USE A NOTEBOOK:
+1. Start with reasoning_notebook
+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 to_do, using the mandated checklist markers.
+
+- to_do: Checklist list of high-level upcoming tasks.
+  Format is mandatory:
+  - "\u{1F5F8}" \u2192 for tasks not yet done (pending)
+  - "[\u2713]" \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>
+
+<agent_end_turn>
+  This tool is mandatory.
+  You must use it to inform the user 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_turn>
+
+### 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
+
+---
+
+## WORKER AGENT OBJECTIVE
+
+You receive a specific task from the Coordinator. Your job is to:
+
+1. **Understand the task** - Read the task description carefully
+2. **Plan your approach** - Use the notebook to break down the work
+3. **Execute autonomously** - Use tools to gather evidence, make changes, and verify
+4. **Report progress** - Keep the Coordinator informed via \`message\` tool
+5. **Verify your work** - Run tests, typechecks, or other validation
+6. **Complete and report** - Call \`agent_end_turn\` with final results
+
+### Task Types
+
+You may be assigned different types of work:
+
+**Research Tasks:**
+- Investigate codebase structure
+- Find specific files or patterns
+- Analyze architectural decisions
+- Report findings with file paths, line numbers, and evidence
+- Do NOT modify files unless explicitly instructed
+
+**Implementation Tasks:**
+- Make targeted code changes
+- Follow best practices and existing patterns
+- Run relevant tests and typechecks
+- Commit changes and report the commit hash
+- Fix root causes, not symptoms
+
+**Verification Tasks:**
+- Test changes made by other workers
+- Run tests with the feature enabled
+- Investigate failures - don't dismiss as unrelated
+- Prove the code works, don't just confirm it exists
+- Report specific evidence (test output, error messages)
+
+**Refactoring Tasks:**
+- Improve code structure without changing behavior
+- Maintain existing functionality
+- Update tests if needed
+- Verify with tests and typechecks
+
+---
+
+## OUTPUT
+
+- Emit \`backend_message\` events through tools only (\`message\`) for progress updates
+- Before making irreversible changes, ensure you have proper authorization or the runtime allows auto-approval
+- Never present draft versions - only produce and deliver final, validated results
+- On successful task completion, emit 'done' with status 'completed' and call \`agent_end_turn\`
+
+---
+
+## 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
+- Never expose secrets or run commands that dump environment variables
+
+---
+
+## EXEMPLAR FLOW (GUIDELINE)
+
+### Research Task Example:
+1. Acknowledge task via \`message\` (info)
+2. Use \`ls_tool\`, \`read_file_lines\`, \`grep_search\` to gather evidence
+3. Track findings in notebook
+4. Report findings via \`message\` (result) with specific file paths and line numbers
+5. Call \`agent_end_turn\`
+
+### Implementation Task Example:
+1. Acknowledge task via \`message\` (info)
+2. Read relevant files to understand current state
+3. Plan changes in notebook
+4. Use \`edit_tool\` to make changes
+5. Run tests via \`shell_command\`
+6. Fix any failures
+7. Commit changes via \`shell_command\` (git commit)
+8. Report commit hash via \`message\` (result)
+9. Call \`agent_end_turn\`
+
+### Verification Task Example:
+1. Acknowledge task via \`message\` (info)
+2. Run tests via \`shell_command\`
+3. Investigate any failures deeply
+4. Report specific evidence (pass/fail, error messages)
+5. Call \`agent_end_turn\` with verdict
+
+---
+
+## CRITICAL REMINDERS
+
+- **You cannot see the Coordinator's conversation** - Your task prompt must be self-contained
+- **Work autonomously** - Don't ask for clarification unless fundamentally blocked
+- **Verify before reporting done** - Run tests, check types, ensure code works
+- **Report specific evidence** - File paths, line numbers, commit hashes, test output
+- **Use the notebook** - Plan, track progress, record decisions
+- **Communicate progress** - Use \`message\` tool frequently with \`message_type: "info"\`
+- **End properly** - Call \`agent_end_turn\` when task is complete
+
+`;
+function getWorkerPrompt() {
+  const now2 = /* @__PURE__ */ new Date();
+  const collectedData = {
+    os_type: os20.type(),
+    os_version: os20.release(),
+    architecture: os20.arch(),
+    workdir: process.cwd(),
+    shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
+    username: os20.userInfo().username || "Unknown",
+    current_date: now2.toISOString().split("T")[0],
+    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
+  };
+  let formattedPrompt = WORKER_SYSTEM_PROMPT;
+  for (const key in finalEnv) {
+    const placeholder = `{${key}}`;
+    formattedPrompt = formattedPrompt.replace(new RegExp(placeholder, "g"), finalEnv[key]);
+  }
+  return formattedPrompt;
+}
+
 // src/app/agent/subagents/base_llm_subagent.ts
 var BaseLLMSubAgent = class {
   ctx;
@@ -11981,7 +12778,7 @@ var BaseLLMSubAgent = class {
     const [sessionFile, history] = await loadOrcreateSession(sessionId);
     this.sessionFile = sessionFile;
     this.history = history || [];
-    const systemPromptContent = getInitPrompt();
+    const systemPromptContent = this.id === "init" ? getInitPrompt() : getWorkerPrompt();
     if (this.history.length === 0) {
       this.history.push({
         role: "system",
@@ -12228,14 +13025,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path34, handler) {
-    this.routeHandlers.set(path34, handler);
+  registerRoute(path35, handler) {
+    this.routeHandlers.set(path35, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext } = payload;
-    for (const [path34, handler] of this.routeHandlers) {
-      if (inputText === path34 || inputText.startsWith(`${path34} `)) {
+    for (const [path35, handler] of this.routeHandlers) {
+      if (inputText === path35 || inputText.startsWith(`${path35} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -12244,13 +13041,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path30 from "path";
+import path31 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function loadPluginsAtStartup() {
   for (const p of listPlugins()) {
     const entry = p.manifest.entry?.trim();
     if (!entry) continue;
-    const abs = path30.resolve(p.root, entry);
+    const abs = path31.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -12271,7 +13068,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path31.join(os20.homedir(), ".bluma", ".env");
+var globalEnvPath = path32.join(os21.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -15044,16 +15841,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import path32 from "path";
-import fs27 from "fs";
+import path33 from "path";
+import fs28 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
 function findBlumaPackageJson(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
-    const candidate = path32.join(dir, "package.json");
-    if (fs27.existsSync(candidate)) {
+    const candidate = path33.join(dir, "package.json");
+    if (fs28.existsSync(candidate)) {
       try {
-        const raw = fs27.readFileSync(candidate, "utf8");
+        const raw = fs28.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -15061,7 +15858,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path32.dirname(dir);
+    const parent = path33.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -15070,13 +15867,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path32.resolve(dir);
+    const abs = path33.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path32.dirname(fileURLToPath5(import.meta.url)));
+    const fromBundle = tryFrom(path33.dirname(fileURLToPath5(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -15084,12 +15881,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path32.isAbsolute(argv1) && fs27.existsSync(argv1)) {
-        resolved = fs27.realpathSync(argv1);
+      if (path33.isAbsolute(argv1) && fs28.existsSync(argv1)) {
+        resolved = fs28.realpathSync(argv1);
       } else {
-        resolved = path32.resolve(process.cwd(), argv1);
+        resolved = path33.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path32.dirname(resolved));
+      const fromArgv = tryFrom(path33.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -16625,9 +17422,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs28.readFileSync(filePath, "utf-8");
+      rawPayload = fs29.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs28.readFileSync(0, "utf-8");
+      rawPayload = fs29.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -16776,7 +17573,9 @@ async function runAgentMode() {
     const agent = new Agent(sessionId, eventBus);
     agentRef = agent;
     await agent.initialize();
-    const userContent = JSON.stringify({
+    const userRequest = envelope.context?.user_request || envelope.context?.userRequest || "";
+    const coordinatorContext = envelope.context?.coordinator_context || envelope.context?.coordinatorContext || "";
+    const userContent = userRequest ? `${userRequest}${coordinatorContext ? "\n\nContexto adicional:\n" + JSON.stringify(coordinatorContext, null, 2) : ""}` : JSON.stringify({
       message_id: envelope.message_id || sessionId,
       from_agent: envelope.from_agent || "unknown",
       to_agent: envelope.to_agent || "bluma",
@@ -16823,9 +17622,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path33.dirname(fileURLToPath6(import.meta.url));
-    const pkgPath = path33.join(base, "..", "package.json");
-    const j = JSON.parse(fs28.readFileSync(pkgPath, "utf8"));
+    const base = path34.dirname(fileURLToPath6(import.meta.url));
+    const pkgPath = path34.join(base, "..", "package.json");
+    const j = JSON.parse(fs29.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -16948,7 +17747,7 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs28.readFileSync(filePath, "utf-8");
+  const rawPayload = fs29.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
   const sessionId = envelope.session_id || envelope.message_id || uuidv48();
   registerSession({