@nomad-e/bluma-cli 0.1.17 → 0.1.19

package/dist/main.js

@@ -1835,7 +1835,7 @@ ${finalDiff}`,
 // src/app/agent/tools/natives/message.ts
 import { v4 as uuidv4 } from "uuid";
 function message(args) {
-  const { content, message_type } = args;
+  const { content, message_type, attachments } = args;
   const result = {
     type: "message",
     message_type,
@@ -1844,6 +1844,7 @@ function message(args) {
     content: {
       body: content
     },
+    attachments: Array.isArray(attachments) ? attachments : void 0,
     success: true,
     delivered: true
   };
@@ -3375,19 +3376,51 @@ async function loadSkill(args) {
       message: `Skill "${skill_name}" not found. Available skills: ${availableNames}`
     };
   }
+  const warnings = [];
+  const conflicts = globalContext.skillLoader.getConflicts();
+  const thisConflict = conflicts.find((c) => c.name === skill_name);
+  if (thisConflict) {
+    warnings.push(
+      `Skill "${skill_name}" exists as a native BluMa skill AND as a user skill at "${thisConflict.userPath}" (${thisConflict.userSource}). The native (bundled) version was loaded. Please rename your custom skill to avoid this conflict.`
+    );
+  }
   if (globalContext.history) {
+    let injected = `[SKILL:${skill.name}]
+
+${skill.content}`;
+    if (skill.references.length > 0 || skill.scripts.length > 0) {
+      injected += "\n\n---\n";
+    }
+    if (skill.references.length > 0) {
+      injected += "\n## Available References\n";
+      for (const ref of skill.references) {
+        injected += `- ${ref.name}: ${ref.path}
+`;
+      }
+      injected += "\nTo read a reference: use read_file_lines with the path above.\n";
+    }
+    if (skill.scripts.length > 0) {
+      injected += "\n## Available Scripts\n";
+      for (const s of skill.scripts) {
+        injected += `- ${s.name}: ${s.path}
+`;
+      }
+      injected += '\nTo run a script: use shell_command with "python <path> [args]".\n';
+    }
     globalContext.history.push({
       role: "user",
-      content: `[SKILL:${skill.name}]
-
-${skill.content}`
+      content: injected
     });
   }
   return {
     success: true,
-    message: `Skill "${skill_name}" loaded successfully. Follow the instructions in the skill content above.`,
+    message: warnings.length > 0 ? `Skill "${skill_name}" loaded (native). WARNING: ${warnings[0]}` : `Skill "${skill_name}" loaded successfully (${skill.source}). Follow the instructions in the skill content above.`,
     skill_name: skill.name,
-    description: skill.description
+    description: skill.description,
+    source: skill.source,
+    warnings: warnings.length > 0 ? warnings : void 0,
+    references: skill.references.length > 0 ? skill.references : void 0,
+    scripts: skill.scripts.length > 0 ? skill.scripts : void 0
   };
 }
 
@@ -3408,8 +3441,8 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path10.dirname(__filename);
-      const configPath = path10.resolve(__dirname, "config", "native_tools.json");
+      const __dirname2 = path10.dirname(__filename);
+      const configPath = path10.resolve(__dirname2, "config", "native_tools.json");
       const fileContent = await fs8.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = config2.nativeTools;
@@ -3499,8 +3532,8 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    const __dirname = path11.dirname(__filename);
-    const defaultConfigPath = path11.resolve(__dirname, "config", "bluma-mcp.json");
+    const __dirname2 = path11.dirname(__filename);
+    const defaultConfigPath = path11.resolve(__dirname2, "config", "bluma-mcp.json");
     const userConfigPath = path11.join(os4.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
@@ -3851,33 +3884,71 @@ import { execSync } from "child_process";
 import fs11 from "fs";
 import path13 from "path";
 import os6 from "os";
-var SkillLoader = class {
+import { fileURLToPath as fileURLToPath3 } from "url";
+var SkillLoader = class _SkillLoader {
+  bundledSkillsDir;
   projectSkillsDir;
   globalSkillsDir;
   cache = /* @__PURE__ */ new Map();
-  constructor(projectRoot) {
+  conflicts = [];
+  constructor(projectRoot, bundledDir) {
     this.projectSkillsDir = path13.join(projectRoot, ".bluma", "skills");
     this.globalSkillsDir = path13.join(os6.homedir(), ".bluma", "skills");
+    this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
+  }
+  /**
+   * Resolve o diretório de skills nativas relativo ao binário (dist/config/skills).
+   * Funciona tanto em ESM como quando executado a partir de dist/.
+   */
+  static resolveBundledDir() {
+    if (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID !== void 0) {
+      if (typeof __dirname !== "undefined") {
+        return path13.join(__dirname, "config", "skills");
+      }
+      return path13.join(process.cwd(), "dist", "config", "skills");
+    }
+    try {
+      const currentFile = fileURLToPath3(import.meta.url);
+      const distDir = path13.dirname(currentFile);
+      return path13.join(distDir, "config", "skills");
+    } catch {
+      return path13.join(process.cwd(), "dist", "config", "skills");
+    }
   }
   /**
-   * Lista skills disponíveis de ambas as fontes
-   * Skills de projeto têm prioridade sobre globais com mesmo nome
+   * Lista skills disponíveis de todas as fontes.
+   * Skills nativas sempre presentes; skills do utilizador com nomes conflitantes são excluídas.
    */
   listAvailable() {
+    this.conflicts = [];
     const skills = /* @__PURE__ */ new Map();
-    const globalSkills = this.listFromDir(this.globalSkillsDir, "global");
-    for (const skill of globalSkills) {
-      skills.set(skill.name, skill);
-    }
-    const projectSkills = this.listFromDir(this.projectSkillsDir, "project");
-    for (const skill of projectSkills) {
+    const bundledSkills = this.listFromDir(this.bundledSkillsDir, "bundled");
+    const bundledNames = new Set(bundledSkills.map((s) => s.name));
+    for (const skill of bundledSkills) {
       skills.set(skill.name, skill);
     }
+    this.mergeUserSkills(skills, bundledNames, this.globalSkillsDir, "global");
+    this.mergeUserSkills(skills, bundledNames, this.projectSkillsDir, "project");
     return Array.from(skills.values());
   }
   /**
-   * Lista skills de um diretório específico
+   * Adiciona skills do utilizador ao mapa, detetando conflitos com nativas.
    */
+  mergeUserSkills(skills, bundledNames, dir, source) {
+    const userSkills = this.listFromDir(dir, source);
+    for (const skill of userSkills) {
+      if (bundledNames.has(skill.name)) {
+        this.conflicts.push({
+          name: skill.name,
+          userSource: source,
+          userPath: path13.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path13.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+        });
+        continue;
+      }
+      skills.set(skill.name, skill);
+    }
+  }
   listFromDir(dir, source) {
     if (!fs11.existsSync(dir)) return [];
     try {
@@ -3889,9 +3960,6 @@ var SkillLoader = class {
       return [];
     }
   }
-  /**
-   * Carrega metadata de um path específico
-   */
   loadMetadataFromPath(skillPath, skillName, source) {
     if (!fs11.existsSync(skillPath)) return null;
     try {
@@ -3910,20 +3978,47 @@ var SkillLoader = class {
     }
   }
   /**
-   * Carrega skill completa - procura primeiro em projeto, depois global
+   * Carrega skill completa.
+   * Ordem: bundled > project > global.
+   * Retorna null se não encontrada.
+   * Lança erro se o nome existir como nativa E como skill do utilizador (conflito).
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
+    const bundledPath = path13.join(this.bundledSkillsDir, name, "SKILL.md");
     const projectPath = path13.join(this.projectSkillsDir, name, "SKILL.md");
-    if (fs11.existsSync(projectPath)) {
+    const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs11.existsSync(bundledPath);
+    const existsProject = fs11.existsSync(projectPath);
+    const existsGlobal = fs11.existsSync(globalPath);
+    if (existsBundled && (existsProject || existsGlobal)) {
+      const conflictSource = existsProject ? "project" : "global";
+      const conflictPath = existsProject ? projectPath : globalPath;
+      const conflict = {
+        name,
+        userSource: conflictSource,
+        userPath: conflictPath,
+        bundledPath
+      };
+      if (!this.conflicts.find((c) => c.name === name)) {
+        this.conflicts.push(conflict);
+      }
+    }
+    if (existsBundled) {
+      const skill = this.loadFromPath(bundledPath, name, "bundled");
+      if (skill) {
+        this.cache.set(name, skill);
+        return skill;
+      }
+    }
+    if (existsProject) {
       const skill = this.loadFromPath(projectPath, name, "project");
       if (skill) {
         this.cache.set(name, skill);
         return skill;
       }
     }
-    const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
-    if (fs11.existsSync(globalPath)) {
+    if (existsGlobal) {
       const skill = this.loadFromPath(globalPath, name, "global");
       if (skill) {
         this.cache.set(name, skill);
@@ -3932,13 +4027,11 @@ var SkillLoader = class {
     }
     return null;
   }
-  /**
-   * Carrega skill de um path específico
-   */
   loadFromPath(skillPath, name, source) {
     try {
       const raw = fs11.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
+      const skillDir = path13.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -3946,15 +4039,28 @@ var SkillLoader = class {
         source,
         version: parsed.version,
         author: parsed.author,
-        license: parsed.license
+        license: parsed.license,
+        references: this.scanAssets(path13.join(skillDir, "references")),
+        scripts: this.scanAssets(path13.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
-  /**
-   * Parse simples de YAML frontmatter
-   */
+  scanAssets(dir) {
+    if (!fs11.existsSync(dir)) return [];
+    try {
+      return fs11.readdirSync(dir).filter((f) => {
+        const fp = path13.join(dir, f);
+        return fs11.statSync(fp).isFile();
+      }).map((f) => ({
+        name: f,
+        path: path13.resolve(dir, f)
+      }));
+    } catch {
+      return [];
+    }
+  }
   parseFrontmatter(raw) {
     const lines = raw.split("\n");
     if (lines[0]?.trim() !== "---") {
@@ -3990,25 +4096,38 @@ var SkillLoader = class {
       content
     };
   }
-  /**
-   * Limpa o cache
-   */
   clearCache() {
     this.cache.clear();
   }
-  /**
-   * Verifica se uma skill existe (em projeto ou global)
-   */
   exists(name) {
+    const bundledPath = path13.join(this.bundledSkillsDir, name, "SKILL.md");
     const projectPath = path13.join(this.projectSkillsDir, name, "SKILL.md");
     const globalPath = path13.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs11.existsSync(projectPath) || fs11.existsSync(globalPath);
+    return fs11.existsSync(bundledPath) || fs11.existsSync(projectPath) || fs11.existsSync(globalPath);
+  }
+  /**
+   * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
+   */
+  getConflicts() {
+    return [...this.conflicts];
   }
   /**
-   * Retorna os diretórios de skills
+   * Verifica se existem conflitos (útil para logs/warnings rápidos).
    */
+  hasConflicts() {
+    return this.conflicts.length > 0;
+  }
+  /**
+   * Formata mensagens de conflito legíveis para o utilizador.
+   */
+  formatConflictWarnings() {
+    return this.conflicts.map(
+      (c) => `Skill "${c.name}" already exists as a native BluMa skill. Your skill at "${c.userPath}" (${c.userSource}) was ignored. Please rename your skill to avoid this conflict.`
+    );
+  }
   getSkillsDirs() {
     return {
+      bundled: this.bundledSkillsDir,
       project: this.projectSkillsDir,
       global: this.globalSkillsDir
     };
@@ -4155,6 +4274,21 @@ var SYSTEM_PROMPT = `
 - NEVER invent skill names that aren't in \`<available_skills>\`
 - NEVER try to \`load_skill\` with a name that isn't in \`<available_skills>\`
 - Your base knowledge (testing, git, docker...) is NOT a skill - it's just knowledge you have
+
+**Progressive Disclosure (Skills with references and scripts):**
+
+Skills may include additional assets beyond the SKILL.md body:
+- \`references/\` \u2014 extra documentation files (e.g. REFERENCE.md, FORMS.md) loaded on-demand.
+- \`scripts/\` \u2014 ready-made executable scripts (e.g. Python) you can run directly.
+
+When you load a skill via \`load_skill\`, the result includes a manifest listing available references and scripts with their absolute paths.
+
+Rules:
+- **Do NOT read references or run scripts unless the task specifically requires them.** The SKILL.md body is often sufficient.
+- To read a reference: use \`read_file_lines\` with the absolute path from the manifest.
+- To run a script: use \`shell_command\` with \`python <absolute_path> [args]\`.
+- The SKILL.md body tells you WHEN to consult each reference or script (e.g. "for forms, read references/FORMS.md").
+- This keeps your context lean \u2014 only load what you need.
 </skills_knowledge>
 
 ---
@@ -4425,56 +4559,93 @@ var SANDBOX_PROMPT_SUFFIX = `
 Sandbox Name: {sandbox_name}
 
 You are running INSIDE an orchestrated sandbox / API container.
+You are NOT talking directly to a human; all inputs come from JSON payloads provided by an orchestrator (the Sandbox API).
 
-In this mode:
-
-- You are NOT talking directly to a human; all inputs come from JSON payloads provided by an orchestrator (the Sandbox API).
-- You MUST avoid interactive flows (no REPL, no prompts that wait for human input, no TUI/CLI menus).
-- You MUST keep all outputs deterministic, concise and structured so that external systems can log and replay your reasoning.
+**Core principles in this mode:**
+- ZERO interactive flows (no REPL, no prompts, no TUI/CLI menus, no \`input()\`).
+- ALL outputs must be deterministic, concise and structured for machine parsing.
+- You own this workspace like a senior developer owns their machine: produce, deliver, clean up.
 
 ### Execution Capabilities (Python-only)
 
-- You are allowed to:
-  - Generate and modify **Python code** (modules, scripts, notebooks, tests).
-  - Propose and run **Python commands only**, e.g.:
-    - \`python main.py\`
-    - \`python -m pytest\`
-  - Use the existing Python environment and preinstalled libraries inside the sandbox (e.g. pandas and other whitelisted packages).
-
-- You are NOT allowed to:
-  - Execute arbitrary shell commands (\`bash\`, \`sh\`, \`zsh\`, \`fish\`, \`cmd\`, \`powershell\`).
-  - Run system-level tools (\`docker\`, \`npm\`, \`node\`, \`git\`, \`curl\`, \`wget\`, package managers, etc.).
-  - Change global system configuration, users, permissions, or network settings.
-  - Depend on interactive stdin/stdout behavior (no \`input()\`, no click/typer prompts).
-
-### Filesystem & IO
-
-- Assume you are working in a **project directory managed by the orchestrator**.
-- You MAY:
-  - Read and write project files (source, tests, configs) as requested by the job.
-  - Create temporary Python files or modules needed to execute the job.
-- You MUST NOT:
-  - Access files outside the project directory tree.
-  - Store secrets or credentials in code or logs.
-  - Rely on long-lived state: each job is independent and may run in a fresh environment.
+You are allowed to:
+- Generate and modify **Python code** (modules, scripts, notebooks, tests).
+- Run **Python commands only**: \`python main.py\`, \`python -m pytest\`, \`python script.py\`, etc.
+- Use the preinstalled Python environment and libraries (pandas, openpyxl, reportlab, etc.).
+
+You are NOT allowed to:
+- Execute arbitrary shell commands (\`bash\`, \`sh\`, \`zsh\`, \`fish\`, \`cmd\`, \`powershell\`).
+- Run system-level tools (\`docker\`, \`npm\`, \`node\`, \`git\`, \`curl\`, \`wget\`, package managers).
+- Change system configuration, users, permissions, or network settings.
+- Use interactive stdin/stdout (\`input()\`, click/typer prompts, curses).
+
+### File Lifecycle in Sandbox (CRITICAL)
+
+You are working in an **isolated job workspace**. Treat it as your personal development machine for this job.
+Follow this workflow for every task that produces deliverables:
+
+**Step 1 \u2014 Analyse** the request and plan what files you need to generate.
+**Step 2 \u2014 Write a script** (e.g. \`_task_runner.py\`) to produce the deliverables programmatically.
+**Step 3 \u2014 Execute the script** via \`shell_command\` (\`python _task_runner.py\`).
+**Step 4 \u2014 Move or create final documents** inside \`./artifacts/\` directory.
+**Step 5 \u2014 Attach deliverables** \u2014 In your final \`message\` tool call (\`message_type: "result"\`), include the **absolute paths** of every deliverable file in the \`attachments\` array.
+**Step 6 \u2014 Clean up** \u2014 Delete all temporary scripts, intermediate files and working data that are NOT final artifacts.
+
+**What MUST go in \`attachments\`:**
+- Documents the user should consume: reports, CSVs, PDFs, spreadsheets, ZIPs, JSON exports, images, etc.
+- Only files that exist inside \`./artifacts/\`.
+- Always use **absolute paths** (e.g. \`/app/artifacts/sales_report.pdf\`).
+
+**What MUST NOT go in \`attachments\`:**
+- Scripts you wrote to generate the deliverables (\`.py\`, \`.sh\`, \`.ipynb\`).
+- Temporary or intermediate files (\`*.tmp\`, \`*.log\`, working data).
+- Internal tooling files.
+
+**Housekeeping rules (before ending the job):**
+- Remove all temporary scripts and working files that are not final artifacts.
+- Ensure \`./artifacts/\` contains ONLY the deliverable documents.
+- Leave the workspace clean, as a real developer would leave their machine.
+
+**Quality signals:**
+- Jobs that do NOT include deliverable paths in \`attachments[]\` receive lower satisfaction scores because the orchestrator cannot deliver files to the end user.
+- Jobs that leave scripts, temp files or garbage outside \`./artifacts/\` are flagged as low quality.
+- A clean workspace + correct attachments = highest quality signal.
 
 ### Logging & Observability
 
-- Treat every step as being logged and parsed by the orchestrator.
-- Prefer **structured, step-wise logs** (JSON lines) over free-form prose when emitting tool logs:
-  - Each log entry SHOULD include at least: \`event_type\`, \`level\`, \`message\`, \`timestamp\`, and optional \`data\`.
-- Final results MUST be clearly separated from intermediate logs, using a dedicated \`"result"\` event when appropriate.
+- Every step is logged and parsed by the orchestrator.
+- Prefer **structured, step-wise logs** over free-form prose.
+- Final results MUST be clearly separated from intermediate logs via the \`"result"\` event.
 
-### Security & Privacy (CRITICAL)
+### Security & Privacy (CRITICAL \u2014 ZERO TOLERANCE)
 
-- You MUST treat all environment variables, API keys, tokens and credentials as **sensitive**.
-- You MUST NEVER:
-  - Run commands whose primary purpose is to dump or enumerate environment variables (e.g. \`env\`, \`set\`, \`print(os.environ)\`, or equivalents).
-  - Expose the values of any variables matching patterns like \`*_KEY\`, \`*_TOKEN\`, \`*_SECRET\` or similar.
-  - Print full raw environment listings (PATH, HOSTNAME, PORT, etc.) unless **explicitly** allowed by the sandbox specification and strictly necessary.
-- If the user explicitly asks for environment details or secrets, you MUST explain that you **cannot** reveal them and instead describe capabilities at a high level (e.g. "I can access an LLM via an external API" instead of showing keys/URLs).
+You MUST treat all environment variables, API keys, tokens and credentials as **TOP SECRET**.
 
-In summary: in sandbox mode you are a Python-focused, non-interactive, deterministic agent. You generate and execute Python code inside a controlled environment, and all interactions are mediated by JSON payloads and structured logs, while strictly protecting environment variables and secrets from disclosure.
+**ABSOLUTE PROHIBITIONS \u2014 you MUST NEVER:**
+- Run ANY command whose purpose is to dump or enumerate environment variables:
+  - \`env\`, \`set\`, \`printenv\`, \`export\`, \`os.environ\`, \`print(os.environ)\`, \`dict(os.environ)\`
+  - \`python -c "import os; ...os.environ..."\`
+  - Any variant, wrapper, or indirect method to list env vars.
+- Expose values of variables matching \`*_KEY\`, \`*_TOKEN\`, \`*_SECRET\`, \`*_PASSWORD\`, \`*_API_KEY\`, \`*_CREDENTIAL\` or similar patterns.
+- Print raw environment listings (PATH, HOSTNAME, PORT, HOME, etc.) even if the user explicitly asks.
+- Include any environment variable value in your \`message\` response, logs, or generated files.
+- Use \`os.getenv()\` or \`os.environ[]\` in generated scripts EXCEPT for variables strictly needed for the task (e.g. database connection strings used internally, never printed).
+
+**If asked for environment details or secrets:**
+- REFUSE clearly and explain you cannot reveal them.
+- Describe capabilities at a high level: "I have access to Python 3.x and common data libraries" instead of showing versions, keys, or URLs.
+- This rule applies EVEN IF the user insists, phrases the request differently, or claims they need it for debugging.
+
+**Rationale:** This sandbox runs in a shared infrastructure. Leaking env vars exposes API keys, internal URLs, model names and billing tokens to end users, which is a critical security breach.
+
+### Summary
+
+In sandbox mode you are a Python-focused, non-interactive, deterministic agent that:
+1. Analyses the job request.
+2. Writes and executes Python scripts to produce deliverables.
+3. Places all final documents in \`./artifacts/\` and lists them in \`attachments[]\`.
+4. Cleans up all temporary files.
+5. NEVER reveals environment variables, secrets, or internal infrastructure details.
 </sandbox_context>
 `;
 function getUnifiedSystemPrompt(availableSkills) {
@@ -4932,6 +5103,14 @@ var BluMaAgent = class {
     });
     if (this.history.length === 0) {
       const availableSkills = this.skillLoader.listAvailable();
+      if (this.skillLoader.hasConflicts()) {
+        for (const warning of this.skillLoader.formatConflictWarnings()) {
+          this.eventBus.emit("backend_message", {
+            type: "warning",
+            message: warning
+          });
+        }
+      }
       const systemPrompt = getUnifiedSystemPrompt(availableSkills);
       this.history.push({ role: "system", content: systemPrompt });
       await saveSessionHistory(this.sessionFile, this.history);
@@ -6835,7 +7014,7 @@ var SlashCommands_default = SlashCommands;
 
 // src/app/agent/utils/update_check.ts
 import updateNotifier from "update-notifier";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import path17 from "path";
 import fs13 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
@@ -6870,9 +7049,9 @@ async function checkForUpdates() {
       pkg = findBlumaPackageJson(path17.dirname(binPath));
     }
     if (!pkg) {
-      const __filename = fileURLToPath3(import.meta.url);
-      const __dirname = path17.dirname(__filename);
-      pkg = findBlumaPackageJson(__dirname);
+      const __filename = fileURLToPath4(import.meta.url);
+      const __dirname2 = path17.dirname(__filename);
+      pkg = findBlumaPackageJson(__dirname2);
     }
     if (!pkg) {
       return null;
@@ -7561,6 +7740,7 @@ async function runAgentMode() {
   const sessionId = envelope.message_id || uuidv43();
   let lastAssistantMessage = null;
   let reasoningBuffer = null;
+  let lastAttachments = null;
   let resultEmitted = false;
   eventBus.on("backend_message", (payload) => {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -7584,6 +7764,10 @@ async function runAgentMode() {
         if (typeof body === "string") {
           lastAssistantMessage = body;
         }
+        const attachments = parsed?.attachments;
+        if (Array.isArray(attachments)) {
+          lastAttachments = attachments.filter((p) => typeof p === "string");
+        }
       } catch {
       }
     }
@@ -7597,7 +7781,8 @@ async function runAgentMode() {
           message_id: envelope.message_id || sessionId,
           action: envelope.action || "unknown",
           last_assistant_message: lastAssistantMessage,
-          reasoning: reasoningBuffer
+          reasoning: reasoningBuffer,
+          attachments: lastAttachments
         }
       });
       process.exit(0);
@@ -7644,7 +7829,8 @@ async function runAgentMode() {
           message_id: envelope.message_id || sessionId,
           action: envelope.action || "unknown",
           last_assistant_message: lastAssistantMessage,
-          reasoning: reasoningBuffer
+          reasoning: reasoningBuffer,
+          attachments: lastAttachments
         }
       });
       process.exit(0);

package/package.json

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

package/dist/config/example.bluma-mcp.json.txt

@@ -1,14 +0,0 @@
-{
-  "mcpServers": {
-    "reasoning": {
-      "type": "stdio",
-      "command": "cmd",
-      "args": [
-        "/c",
-        "npx",
-        "-y",
-        "@sousaalex1605/bluma-nootebook"
-      ]
-    }
-  }
-}

package/dist/config/models_config.json

@@ -1,78 +0,0 @@
-{
-  "models": [
-    {
-      "id": "google/gemini-3.1-pro-preview-customtools",
-      "tier": "tools",
-      "task_type": "multi_tool",
-      "context_window": 1048576,
-      "pricing": {
-        "input_per_1m_tokens": "$2.00",
-        "output_per_1m_tokens": "$12.00"
-      },
-      "description": "Enhanced version of Gemini 3.1 Pro tuned specifically for reliable tool selection and function calling. Designed to avoid overusing generic shell tools when more targeted tools are available, making it ideal for complex coding agents and multi-tool workflows in the CLI.",
-      "best_for": [
-        "Workflows that involve many different tools (file operations, search, tests, shell) and require the model to pick the right one.",
-        "Coordinating multi-step coding tasks where safe and accurate tool use is more important than raw speed or cost.",
-        "Complex debugging or refactors that need mixing code edits, search, tests, and shell commands.",
-        "Agent-style tasks where tool misuse is risky and you want maximum reliability in tool choice."
-      ],
-      "not_for": "Very simple edits, quick questions, or cheap one-off operations that qwen3.5-flash can handle more economically."
-    },
-    {
-      "id": "qwen/qwen3-coder-next",
-      "tier": "coder",
-      "task_type": "multi_file",
-      "context_window": 262144,
-      "pricing": {
-        "input_per_1m_tokens": "$0.12",
-        "output_per_1m_tokens": "$0.75"
-      },
-      "description": "Coder-focused MoE model optimized for long-horizon coding agents and local development workflows. Handles large codebases, multi-file refactors, and recovery from execution failures while remaining cost-effective for always-on agents.",
-      "best_for": [
-        "Large refactors across many files where the agent must keep track of a global design.",
-        "Implementing new subsystems (features, services, modules) with tests and documentation.",
-        "Agentic coding loops that involve planning, executing edits, running commands/tests, and iterating.",
-        "Complex bug-hunting sessions where the model must reason over many files and past attempts."
-      ],
-      "not_for": "Tiny edits, trivial Q&A, or ultra-simple tasks where qwen3.5-flash is cheaper and fast enough."
-    },
-    {
-      "id": "deepseek/deepseek-chat-v3.1",
-      "tier": "reasoning",
-      "task_type": "reasoning",
-      "context_window": 32768,
-      "pricing": {
-        "input_per_1m_tokens": "$0.15",
-        "output_per_1m_tokens": "$0.75"
-      },
-      "description": "Hybrid reasoning model supporting both thinking and non-thinking modes with strong performance on coding, tool use, and long-context reasoning. Good choice when deep structured reasoning or complex analysis is needed in addition to code generation.",
-      "best_for": [
-        "Deep reasoning on tricky bugs, architecture decisions, or algorithm design.",
-        "Analyzing logs, traces, or large textual outputs to identify root causes.",
-        "Complex code reviews or design reviews where clear, structured justification is needed.",
-        "Cases where you explicitly want more deliberate reasoning rather than only fast responses."
-      ],
-      "not_for": "Purely mechanical edits or very simple tasks where a cheaper, faster model is sufficient."
-    },
-    {
-      "id": "anthropic/claude-haiku-4.5",
-      "tier": "heavy",
-      "task_type": "complex",
-      "context_window": 200000,
-      "pricing": {
-        "input_per_1m_tokens": "$1.00",
-        "output_per_1m_tokens": "$5.00"
-      },
-      "description": "High-end, high-speed frontier model with extended thinking and strong performance on coding, reasoning, and computer-use tasks. Best reserved for the most complex, high-stakes workflows where you need frontier-level capability and robustness.",
-      "best_for": [
-        "Very large, high-risk changes to critical production code where maximum reliability matters.",
-        "Long, multi-phase agentic tasks that must not fail (e.g. migrations, deep refactors, safety-sensitive changes).",
-        "Scenarios where you want frontier-level coding performance and can afford higher cost.",
-        "Coordinating many sub-agents or parallel tool workflows for large projects."
-      ],
-      "not_for": "Routine day-to-day coding tasks, quick fixes, or low-impact work where cheaper models are perfectly adequate."
-    }
-  ],
-  "default_model": "qwen/qwen3-coder-next"
-}
-