@nomad-e/bluma-cli 0.1.52 → 0.1.53

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,315 @@ 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/prompt_builder.ts
 function getNodeVersion() {
   try {
@@ -9570,10 +9877,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 +9888,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 +9909,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 +9920,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 +9928,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`;
     }
@@ -9772,7 +10079,7 @@ 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.
+Final deliverables under \`./.bluma/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>
 `;
@@ -9839,13 +10146,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 +10893,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 +10905,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 +10924,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 +10951,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 +11050,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 +11064,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 +11110,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 +11705,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 +12262,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 +12567,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 +12814,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 +12830,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 +12857,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 +15630,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 +15647,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path32.dirname(dir);
+    const parent = path33.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -15070,13 +15656,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 +15670,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 +17211,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 +17362,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 +17411,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 +17536,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({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.1.52",
+	"version": "0.1.53",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",