@nomad-e/bluma-cli 0.7.0 → 0.8.0

package/dist/main.js

@@ -291,6 +291,15 @@ function getSandboxPolicy() {
     workspaceRoot
   };
 }
+function getArtifactsDirectory(policy = getSandboxPolicy()) {
+  return path6.join(policy.workspaceRoot, ".bluma", "artifacts");
+}
+function isPathInsideArtifactsDirectory(resolvedAbsolutePath, policy = getSandboxPolicy()) {
+  const artifactsRoot = getArtifactsDirectory(policy);
+  const resolved = path6.resolve(resolvedAbsolutePath);
+  const relative = path6.relative(artifactsRoot, resolved);
+  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+}
 function isPathInsideWorkspace(targetPath, policy = getSandboxPolicy()) {
   const resolved = path6.resolve(targetPath);
   const relative = path6.relative(policy.workspaceRoot, resolved);
@@ -397,11 +406,11 @@ var init_sandbox_policy = __esm({
 });
 
 // src/app/agent/runtime/task_store.ts
-import fs12 from "fs";
-import path10 from "path";
+import fs13 from "fs";
+import path11 from "path";
 function getStorePath() {
   const policy = getSandboxPolicy();
-  return path10.join(policy.workspaceRoot, ".bluma", "task_state.json");
+  return path11.join(policy.workspaceRoot, ".bluma", "task_state.json");
 }
 function getDefaultState() {
   return {
@@ -417,8 +426,8 @@ function ensureLoaded() {
     return cache2;
   }
   try {
-    if (fs12.existsSync(storePath)) {
-      const raw = fs12.readFileSync(storePath, "utf-8");
+    if (fs13.existsSync(storePath)) {
+      const raw = fs13.readFileSync(storePath, "utf-8");
       const parsed = JSON.parse(raw);
       cache2 = {
         tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
@@ -437,9 +446,9 @@ function ensureLoaded() {
 }
 function persist(state2) {
   const storePath = getStorePath();
-  fs12.mkdirSync(path10.dirname(storePath), { recursive: true });
+  fs13.mkdirSync(path11.dirname(storePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs12.writeFileSync(storePath, JSON.stringify(state2, null, 2), "utf-8");
+  fs13.writeFileSync(storePath, JSON.stringify(state2, null, 2), "utf-8");
   cache2 = state2;
   cachePath = storePath;
 }
@@ -826,37 +835,37 @@ __export(session_registry_exports, {
   removeSession: () => removeSession,
   updateSession: () => updateSession
 });
-import fs18 from "fs";
+import fs19 from "fs";
 import os13 from "os";
-import path18 from "path";
+import path19 from "path";
 function getRegistryDir() {
-  return path18.join(process.env.HOME || os13.homedir(), ".bluma", "registry");
+  return path19.join(process.env.HOME || os13.homedir(), ".bluma", "registry");
 }
 function getRegistryFile() {
-  return path18.join(getRegistryDir(), "sessions.json");
+  return path19.join(getRegistryDir(), "sessions.json");
 }
 function ensureRegistryDir() {
-  fs18.mkdirSync(getRegistryDir(), { recursive: true });
+  fs19.mkdirSync(getRegistryDir(), { recursive: true });
 }
 function readRegistry() {
   ensureRegistryDir();
   const file = getRegistryFile();
-  if (!fs18.existsSync(file)) {
+  if (!fs19.existsSync(file)) {
     return { entries: [] };
   }
   try {
-    return JSON.parse(fs18.readFileSync(file, "utf-8"));
+    return JSON.parse(fs19.readFileSync(file, "utf-8"));
   } catch {
     return { entries: [] };
   }
 }
 function writeRegistry(state2) {
   ensureRegistryDir();
-  fs18.writeFileSync(getRegistryFile(), JSON.stringify(state2, null, 2), "utf-8");
+  fs19.writeFileSync(getRegistryFile(), JSON.stringify(state2, null, 2), "utf-8");
 }
 function getSessionLogPath(sessionId) {
   ensureRegistryDir();
-  return path18.join(getRegistryDir(), `${sessionId}.jsonl`);
+  return path19.join(getRegistryDir(), `${sessionId}.jsonl`);
 }
 function registerSession(entry) {
   const state2 = readRegistry();
@@ -901,13 +910,13 @@ function removeSession(sessionId) {
 }
 function appendSessionLog(sessionId, payload) {
   const logFile = getSessionLogPath(sessionId);
-  fs18.appendFileSync(logFile, `${JSON.stringify(payload)}
+  fs19.appendFileSync(logFile, `${JSON.stringify(payload)}
 `, "utf-8");
 }
 function readSessionLog(sessionId) {
   const logFile = getSessionLogPath(sessionId);
-  if (!fs18.existsSync(logFile)) return [];
-  return fs18.readFileSync(logFile, "utf-8").split("\n").filter(Boolean);
+  if (!fs19.existsSync(logFile)) return [];
+  return fs19.readFileSync(logFile, "utf-8").split("\n").filter(Boolean);
 }
 var init_session_registry = __esm({
   "src/app/agent/runtime/session_registry.ts"() {
@@ -916,17 +925,17 @@ var init_session_registry = __esm({
 });
 
 // src/app/agent/utils/logger.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import os14 from "os";
-import path19 from "path";
+import path20 from "path";
 function getLogDir() {
-  const dir = path19.join(process.env.HOME || os14.homedir(), ".bluma", "logs");
-  fs19.mkdirSync(dir, { recursive: true });
+  const dir = path20.join(process.env.HOME || os14.homedir(), ".bluma", "logs");
+  fs20.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function getLogFilePath() {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return path19.join(getLogDir(), `bluma-${today}.log`);
+  return path20.join(getLogDir(), `bluma-${today}.log`);
 }
 var BluMaLogger, logger;
 var init_logger = __esm({
@@ -956,7 +965,7 @@ var init_logger = __esm({
           turnId: this.turnId
         };
         try {
-          fs19.appendFileSync(this.logFile, JSON.stringify(logEntry) + "\n");
+          fs20.appendFileSync(this.logFile, JSON.stringify(logEntry) + "\n");
         } catch {
         }
         if (this.consoleEnabled) {
@@ -1057,19 +1066,19 @@ __export(mailbox_registry_exports, {
   sendSignal: () => sendSignal,
   sendToMailbox: () => sendToMailbox
 });
-import fs20 from "fs";
+import fs21 from "fs";
 import os15 from "os";
-import path20 from "path";
+import path21 from "path";
 import { EventEmitter as EventEmitter4 } from "events";
 import { v4 as uuidv45 } from "uuid";
 function getMailboxesDir() {
   if (mailboxesDir) return mailboxesDir;
-  mailboxesDir = path20.join(process.env.HOME || os15.homedir(), ".bluma", "mailboxes");
-  fs20.mkdirSync(mailboxesDir, { recursive: true });
+  mailboxesDir = path21.join(process.env.HOME || os15.homedir(), ".bluma", "mailboxes");
+  fs21.mkdirSync(mailboxesDir, { recursive: true });
   return mailboxesDir;
 }
 function getMailboxPath(sessionId, type) {
-  return path20.join(getMailboxesDir(), `${sessionId}.${type}`);
+  return path21.join(getMailboxesDir(), `${sessionId}.${type}`);
 }
 function sendToMailbox(sessionId, type, message2) {
   return mailbox.sendToMailbox(sessionId, type, message2);
@@ -1095,7 +1104,7 @@ function pruneMailbox(sessionId, type, keepLast = 100) {
   const pruned = queue.slice(-keepLast);
   mailbox.queues.set(sessionId, pruned);
   const filePath = getMailboxPath(sessionId, type);
-  fs20.writeFileSync(filePath, pruned.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
+  fs21.writeFileSync(filePath, pruned.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
 }
 function listActiveMailboxes() {
   const result = [];
@@ -1163,16 +1172,16 @@ var init_mailbox_registry = __esm({
       loadExistingMailboxes() {
         try {
           const dir = getMailboxesDir();
-          const files = fs20.readdirSync(dir);
+          const files = fs21.readdirSync(dir);
           for (const file of files) {
             if (!file.endsWith(".in") && !file.endsWith(".out") && !file.endsWith(".sig")) {
               continue;
             }
             const type = file.split(".").pop();
             const sessionId = file.slice(0, -(type.length + 1));
-            const filePath = path20.join(dir, file);
+            const filePath = path21.join(dir, file);
             try {
-              const content = fs20.readFileSync(filePath, "utf-8");
+              const content = fs21.readFileSync(filePath, "utf-8");
               const lines = content.trim().split("\n").filter(Boolean);
               const messages = [];
               for (const line of lines) {
@@ -1209,7 +1218,7 @@ var init_mailbox_registry = __esm({
         this.queues.set(sessionId, queue);
         try {
           const filePath = getMailboxPath(sessionId, type);
-          fs20.appendFileSync(filePath, JSON.stringify(fullMessage) + "\n", "utf-8");
+          fs21.appendFileSync(filePath, JSON.stringify(fullMessage) + "\n", "utf-8");
         } catch {
         }
         this.emit(`message:${sessionId}`, fullMessage);
@@ -1258,7 +1267,7 @@ var init_mailbox_registry = __esm({
         this.emit(`signal:${sessionId}`, signal);
         try {
           const filePath = getMailboxPath(sessionId, "sig");
-          fs20.appendFileSync(filePath, JSON.stringify(signal) + "\n", "utf-8");
+          fs21.appendFileSync(filePath, JSON.stringify(signal) + "\n", "utf-8");
         } catch {
         }
         return signal.id;
@@ -1272,9 +1281,9 @@ var init_mailbox_registry = __esm({
       ensureMailbox(sessionId) {
         const dir = getMailboxesDir();
         for (const type of ["in", "out", "sig"]) {
-          const filePath = path20.join(dir, `${sessionId}.${type}`);
-          if (!fs20.existsSync(filePath)) {
-            fs20.writeFileSync(filePath, "", "utf-8");
+          const filePath = path21.join(dir, `${sessionId}.${type}`);
+          if (!fs21.existsSync(filePath)) {
+            fs21.writeFileSync(filePath, "", "utf-8");
           }
         }
       }
@@ -1284,8 +1293,8 @@ var init_mailbox_registry = __esm({
       removeMailbox(sessionId) {
         const dir = getMailboxesDir();
         for (const type of ["in", "out", "sig"]) {
-          const filePath = path20.join(dir, `${sessionId}.${type}`);
-          if (fs20.existsSync(filePath)) fs20.unlinkSync(filePath);
+          const filePath = path21.join(dir, `${sessionId}.${type}`);
+          if (fs21.existsSync(filePath)) fs21.unlinkSync(filePath);
         }
         this.queues.delete(sessionId);
         this.signalQueues.delete(sessionId);
@@ -1304,9 +1313,9 @@ __export(AgentCoordinationTool_exports, {
   spawnAgent: () => spawnAgent,
   waitAgent: () => waitAgent
 });
-import fs21 from "fs";
+import fs22 from "fs";
 import os16 from "os";
-import path21 from "path";
+import path22 from "path";
 import { spawn as spawn4 } from "child_process";
 import { v4 as uuidv46 } from "uuid";
 function readUserContextFromEnv() {
@@ -1420,10 +1429,10 @@ async function spawnAgent(args) {
     spawnLog.error("Payload NOT serializable", { error: e.message });
     throw new BluMaError("WORKER_CONTEXT_NOT_SERIALIZABLE" /* WORKER_CONTEXT_NOT_SERIALIZABLE */, `Worker context is not JSON-serializable: ${e.message}`);
   }
-  const payloadDir = fs21.mkdtempSync(path21.join(os16.tmpdir(), "bluma-worker-"));
-  const payloadPath = path21.join(payloadDir, `${sessionId}.json`);
+  const payloadDir = fs22.mkdtempSync(path22.join(os16.tmpdir(), "bluma-worker-"));
+  const payloadPath = path22.join(payloadDir, `${sessionId}.json`);
   try {
-    fs21.writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
+    fs22.writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
     spawnLog.debug("Payload written", { payloadPath });
   } catch (e) {
     spawnLog.error("Failed to write payload", { error: e.message, payloadPath });
@@ -2192,11 +2201,11 @@ var NodeFsOperations = {
       if (fd) fs.closeSync(fd);
     }
   },
-  appendFileSync(path50, data, options) {
-    const _ = slowLogging`fs.appendFileSync(${path50}, ${data.length} chars)`;
+  appendFileSync(path51, data, options) {
+    const _ = slowLogging`fs.appendFileSync(${path51}, ${data.length} chars)`;
     if (options?.mode !== void 0) {
       try {
-        const fd = fs.openSync(path50, "ax", options.mode);
+        const fd = fs.openSync(path51, "ax", options.mode);
         try {
           fs.appendFileSync(fd, data);
         } finally {
@@ -2207,35 +2216,35 @@ var NodeFsOperations = {
         if (getErrnoCode(e) !== "EEXIST") throw e;
       }
     }
-    fs.appendFileSync(path50, data);
+    fs.appendFileSync(path51, data);
   },
   copyFileSync(src, dest) {
     const _ = slowLogging`fs.copyFileSync(${src} → ${dest})`;
     fs.copyFileSync(src, dest);
   },
-  unlinkSync(path50) {
-    const _ = slowLogging`fs.unlinkSync(${path50})`;
-    fs.unlinkSync(path50);
+  unlinkSync(path51) {
+    const _ = slowLogging`fs.unlinkSync(${path51})`;
+    fs.unlinkSync(path51);
   },
   renameSync(oldPath, newPath) {
     const _ = slowLogging`fs.renameSync(${oldPath} → ${newPath})`;
     fs.renameSync(oldPath, newPath);
   },
-  linkSync(target, path50) {
-    const _ = slowLogging`fs.linkSync(${target} → ${path50})`;
-    fs.linkSync(target, path50);
+  linkSync(target, path51) {
+    const _ = slowLogging`fs.linkSync(${target} → ${path51})`;
+    fs.linkSync(target, path51);
   },
-  symlinkSync(target, path50, type) {
-    const _ = slowLogging`fs.symlinkSync(${target} → ${path50})`;
-    fs.symlinkSync(target, path50, type);
+  symlinkSync(target, path51, type) {
+    const _ = slowLogging`fs.symlinkSync(${target} → ${path51})`;
+    fs.symlinkSync(target, path51, type);
   },
-  readlinkSync(path50) {
-    const _ = slowLogging`fs.readlinkSync(${path50})`;
-    return fs.readlinkSync(path50);
+  readlinkSync(path51) {
+    const _ = slowLogging`fs.readlinkSync(${path51})`;
+    return fs.readlinkSync(path51);
   },
-  realpathSync(path50) {
-    const _ = slowLogging`fs.realpathSync(${path50})`;
-    return fs.realpathSync(path50).normalize("NFC");
+  realpathSync(path51) {
+    const _ = slowLogging`fs.realpathSync(${path51})`;
+    return fs.realpathSync(path51).normalize("NFC");
   },
   mkdirSync(dirPath, options) {
     const _ = slowLogging`fs.mkdirSync(${dirPath})`;
@@ -2268,12 +2277,12 @@ var NodeFsOperations = {
     const _ = slowLogging`fs.rmdirSync(${dirPath})`;
     fs.rmdirSync(dirPath);
   },
-  rmSync(path50, options) {
-    const _ = slowLogging`fs.rmSync(${path50})`;
-    fs.rmSync(path50, options);
+  rmSync(path51, options) {
+    const _ = slowLogging`fs.rmSync(${path51})`;
+    fs.rmSync(path51, options);
   },
-  createWriteStream(path50) {
-    return fs.createWriteStream(path50);
+  createWriteStream(path51) {
+    return fs.createWriteStream(path51);
   },
   async readFileBytes(fsPath, maxBytes) {
     if (maxBytes === void 0) {
@@ -2380,12 +2389,12 @@ function shouldLogDebugMessage(message2) {
 var hasFormattedOutput = false;
 var debugWriter = null;
 var pendingWrite = Promise.resolve();
-async function appendAsync(needMkdir, dir, path50, content) {
+async function appendAsync(needMkdir, dir, path51, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {
     });
   }
-  await appendFile(path50, content);
+  await appendFile(path51, content);
   void updateLatestDebugLogSymlink();
 }
 function noop() {
@@ -2395,8 +2404,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path50 = getDebugLogPath();
-        const dir = dirname(path50);
+        const path51 = getDebugLogPath();
+        const dir = dirname(path51);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -2406,11 +2415,11 @@ function getDebugWriter() {
             } catch {
             }
           }
-          getFsImplementation().appendFileSync(path50, content);
+          getFsImplementation().appendFileSync(path51, content);
           void updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path50, content)).catch(noop);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path51, content)).catch(noop);
       },
       flushIntervalMs: 1e3,
       maxBufferSize: 100,
@@ -8597,8 +8606,8 @@ import codeExcerpt from "code-excerpt";
 import { readFileSync as readFileSync2 } from "fs";
 import StackUtils from "stack-utils";
 import { jsx as jsx6, jsxs } from "react/jsx-runtime";
-var cleanupPath = (path50) => {
-  return path50?.replace(`file://${process.cwd()}/`, "");
+var cleanupPath = (path51) => {
+  return path51?.replace(`file://${process.cwd()}/`, "");
 };
 var stackUtils;
 function getStackUtils() {
@@ -12575,8 +12584,8 @@ var getInstance = (stdout, createInstance) => {
 
 // src/main.ts
 import { EventEmitter as EventEmitter7 } from "events";
-import fs46 from "fs";
-import path49 from "path";
+import fs47 from "fs";
+import path50 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
@@ -15120,12 +15129,12 @@ InputPrompt.displayName = "InputPrompt";
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path43 from "path";
+import path44 from "path";
 import os32 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs28 } from "fs";
-import path28 from "path";
+import { promises as fs29 } from "fs";
+import path29 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/app/agent/tools/EditTool/EditTool.ts
@@ -15668,8 +15677,168 @@ ${finalDiff}`,
 
 // src/app/agent/tools/MessageTool/MessageTool.ts
 import { v4 as uuidv42 } from "uuid";
+
+// src/app/agent/runtime/sandbox_message_validation.ts
+init_sandbox_policy();
+import fs9 from "fs";
+import path8 from "path";
+var HTTP_URL_PATTERN = /^https?:\/\//i;
+function normalizeAttachmentPath(entry) {
+  if (typeof entry === "string") {
+    const trimmed = entry.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  if (entry && typeof entry === "object" && "path" in entry) {
+    const pathValue = entry.path;
+    if (typeof pathValue === "string") {
+      const trimmed = pathValue.trim();
+      return trimmed.length > 0 ? trimmed : null;
+    }
+  }
+  return null;
+}
+function looksLikeHttpUrl(value) {
+  return HTTP_URL_PATTERN.test(value.trim());
+}
+function taskExpectsFileDeliverable(userRequest) {
+  if (!userRequest || !userRequest.trim()) {
+    return false;
+  }
+  const text = userRequest.toLowerCase();
+  return /\b(pdf|excel|xlsx|csv|docx|documento|relat[oó]rio|ficheiro|arquivo|export|download|artifact|artefacto|anexo)\b/i.test(
+    text
+  );
+}
+function validateSandboxMessageDeliverables(args, policy = getSandboxPolicy(), options) {
+  if (!policy.isSandbox) {
+    return { ok: true };
+  }
+  if (args.message_type !== "result") {
+    return { ok: true };
+  }
+  const attachments = args.attachments;
+  const hasAttachments = Array.isArray(attachments) && attachments.length > 0;
+  if (!hasAttachments && taskExpectsFileDeliverable(options?.userRequest)) {
+    return {
+      ok: false,
+      error: "File deliverables must use attachments[]",
+      details: 'Write the file under .bluma/artifacts/ with file_write, then call message(result) with attachments: [".bluma/artifacts/<filename>"]. Paths in content alone are not delivered to the orchestrator.'
+    };
+  }
+  if (!hasAttachments) {
+    return { ok: true };
+  }
+  for (const entry of attachments) {
+    const raw = normalizeAttachmentPath(entry);
+    if (!raw) {
+      return {
+        ok: false,
+        error: "Invalid attachment entry",
+        details: 'Each attachment must be a workspace file path (string) or { path: ".bluma/artifacts/..." }. URLs are not allowed.'
+      };
+    }
+    if (looksLikeHttpUrl(raw)) {
+      return {
+        ok: false,
+        error: "Attachments cannot be URLs in sandbox",
+        details: `Rejected "${raw}". Use file_write to create a file under .bluma/artifacts/ and pass that path in attachments[].`
+      };
+    }
+    let resolved;
+    try {
+      resolved = resolveWorkspacePath(raw, policy);
+    } catch (err) {
+      return {
+        ok: false,
+        error: "Attachment path is outside the sandbox workspace",
+        details: err instanceof Error ? err.message : String(err)
+      };
+    }
+    if (!fs9.existsSync(resolved)) {
+      return {
+        ok: false,
+        error: "Attachment file does not exist",
+        details: `Create the deliverable first (file_write \u2192 .bluma/artifacts/...). Missing: ${resolved}`
+      };
+    }
+    const stat = fs9.statSync(resolved);
+    if (!stat.isFile()) {
+      return {
+        ok: false,
+        error: "Attachment must be a file",
+        details: resolved
+      };
+    }
+    if (!isPathInsideArtifactsDirectory(resolved, policy)) {
+      const artifactsDir2 = getArtifactsDirectory(policy);
+      return {
+        ok: false,
+        error: "Files are delivered only via .bluma/artifacts/",
+        details: `Move or copy the deliverable to ${path8.relative(policy.workspaceRoot, artifactsDir2)}/ and pass that path in attachments[]. Rejected: ${raw}`
+      };
+    }
+  }
+  return { ok: true };
+}
+
+// src/app/agent/tools/MessageTool/normalize_args.ts
+function normalizeMessageToolArgs(raw) {
+  const content = typeof raw.content === "string" ? raw.content : typeof raw.body === "string" ? raw.body : typeof raw.text === "string" ? raw.text : "";
+  const messageTypeRaw = raw.message_type ?? raw.messageType ?? raw.type ?? raw.kind ?? "info";
+  const message_type = String(messageTypeRaw).toLowerCase() === "result" ? "result" : "info";
+  let attachments;
+  const rawAttachments = raw.attachments;
+  if (Array.isArray(rawAttachments)) {
+    attachments = rawAttachments.map((entry) => {
+      if (typeof entry === "string") {
+        return entry.trim();
+      }
+      if (entry && typeof entry === "object" && "path" in entry) {
+        const pathValue = entry.path;
+        return typeof pathValue === "string" ? pathValue.trim() : "";
+      }
+      return "";
+    }).filter((value) => value.length > 0);
+  } else if (typeof rawAttachments === "string" && rawAttachments.trim()) {
+    try {
+      const parsed = JSON.parse(rawAttachments);
+      if (Array.isArray(parsed)) {
+        attachments = parsed.filter((value) => typeof value === "string");
+      }
+    } catch {
+      attachments = [rawAttachments.trim()];
+    }
+  }
+  return {
+    content,
+    message_type,
+    attachments: attachments?.length ? attachments : void 0
+  };
+}
+
+// src/app/agent/tools/MessageTool/MessageTool.ts
 function message(args) {
-  const { content, message_type, attachments } = args;
+  const { content, message_type, attachments } = normalizeMessageToolArgs(
+    args
+  );
+  const deliverableCheck = validateSandboxMessageDeliverables(
+    {
+      message_type,
+      attachments,
+      content
+    },
+    void 0,
+    { userRequest: process.env.BLUMA_USER_REQUEST }
+  );
+  if (!deliverableCheck.ok) {
+    return Promise.resolve({
+      status: "error",
+      success: false,
+      error: deliverableCheck.error,
+      details: deliverableCheck.details,
+      message_type
+    });
+  }
   const result = {
     type: "message",
     message_type,
@@ -15686,8 +15855,8 @@ function message(args) {
 }
 
 // src/app/agent/tools/LsTool/LsTool.ts
-import { promises as fs9 } from "fs";
-import path8 from "path";
+import { promises as fs10 } from "fs";
+import path9 from "path";
 import os7 from "os";
 import { minimatch } from "minimatch";
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
@@ -15707,7 +15876,7 @@ var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
 ]);
 function expandPath(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path8.join(os7.homedir(), p.slice(2));
+    return path9.join(os7.homedir(), p.slice(2));
   }
   return p;
 }
@@ -15733,8 +15902,8 @@ async function ls(args) {
     max_depth
   } = args;
   try {
-    const basePath = path8.resolve(expandPath(directory_path));
-    const stat = await fs9.stat(basePath).catch(() => null);
+    const basePath = path9.resolve(expandPath(directory_path));
+    const stat = await fs10.stat(basePath).catch(() => null);
     if (!stat || !stat.isDirectory()) {
       throw new Error(`Directory '${directory_path}' not found.`);
     }
@@ -15746,11 +15915,11 @@ async function ls(args) {
     const allDirs = [];
     const walk = async (currentDir, currentDepth) => {
       if (max_depth !== void 0 && currentDepth >= max_depth) return;
-      const entries = await fs9.readdir(currentDir, { withFileTypes: true });
+      const entries = await fs10.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         const entryName = entry.name;
-        const fullPath = path8.join(currentDir, entryName);
-        const relativePath = path8.relative(basePath, fullPath).split(path8.sep).join("/");
+        const fullPath = path9.join(currentDir, entryName);
+        const relativePath = path9.relative(basePath, fullPath).split(path9.sep).join("/");
         const isHidden = entryName.startsWith(".");
         if (shouldIgnore(entryName, allIgnorePatterns) || isHidden && !show_hidden) {
           continue;
@@ -15759,7 +15928,7 @@ async function ls(args) {
           allDirs.push(relativePath);
           if (recursive) await walk(fullPath, currentDepth + 1);
         } else if (entry.isFile()) {
-          if (!normalizedExtensions || normalizedExtensions.includes(path8.extname(entryName).toLowerCase())) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path9.extname(entryName).toLowerCase())) {
             allFiles.push(relativePath);
           }
         }
@@ -15772,7 +15941,7 @@ async function ls(args) {
     const dirEnd = end_index ?? allDirs.length;
     return {
       success: true,
-      path: basePath.split(path8.sep).join("/"),
+      path: basePath.split(path9.sep).join("/"),
       recursive,
       total_files: allFiles.length,
       total_directories: allDirs.length,
@@ -15794,13 +15963,13 @@ async function ls(args) {
 
 // src/app/agent/tools/ReadLinesTool/ReadLinesTool.ts
 init_sandbox_policy();
-import { promises as fs10 } from "fs";
-import path9 from "path";
+import { promises as fs11 } from "fs";
+import path10 from "path";
 import os8 from "os";
 var DEFAULT_LINE_WINDOW = 2e3;
 function expandPath2(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path9.join(os8.homedir(), p.slice(2));
+    return path10.join(os8.homedir(), p.slice(2));
   }
   return p;
 }
@@ -15818,7 +15987,7 @@ async function readLines(args) {
   }
   try {
     const resolvedPath = resolveWorkspacePath(expandPath2(filepath));
-    const stat = await fs10.stat(resolvedPath).catch(() => null);
+    const stat = await fs11.stat(resolvedPath).catch(() => null);
     if (!stat || !stat.isFile()) {
       const workspaceRoot = resolveWorkspacePath(".");
       const isInsideWorkspace = resolvedPath.startsWith(workspaceRoot);
@@ -15837,7 +16006,7 @@ async function readLines(args) {
     if (endLine < startLine) {
       throw new Error("Invalid line range: end_line must be >= start_line.");
     }
-    const fileContent = await fs10.readFile(resolvedPath, "utf-8");
+    const fileContent = await fs11.readFile(resolvedPath, "utf-8");
     const lines = fileContent.split("\n");
     const total_lines = lines.length;
     const startIndex = startLine - 1;
@@ -15868,7 +16037,7 @@ async function readLines(args) {
 
 // src/app/agent/tools/CountLinesTool/CountLinesTool.ts
 import { createReadStream } from "fs";
-import { promises as fs11 } from "fs";
+import { promises as fs12 } from "fs";
 import readline from "readline";
 async function countLines(args) {
   const filepathInput = typeof args?.filepath === "string" && args.filepath.trim().length > 0 ? args.filepath : typeof args?.file_path === "string" ? args.file_path : "";
@@ -15895,7 +16064,7 @@ async function countLines(args) {
     };
   }
   try {
-    if (!(await fs11.stat(filepath)).isFile()) {
+    if (!(await fs12.stat(filepath)).isFile()) {
       throw new Error(`File '${filepath}' not found or is not a file.`);
     }
     const fileStream = createReadStream(filepath);
@@ -16085,7 +16254,7 @@ function formatTodoResult(result) {
 
 // src/app/agent/tools/FindByNameTool/FindByNameTool.ts
 init_sandbox_policy();
-import path11 from "path";
+import path12 from "path";
 import { promises as fsPromises } from "fs";
 import os9 from "os";
 var MAX_RESULTS2 = 100;
@@ -16109,7 +16278,7 @@ var DEFAULT_IGNORE2 = /* @__PURE__ */ new Set([
 ]);
 function expandTilde2(p) {
   if (p === "~") return os9.homedir();
-  if (p.startsWith("~/")) return path11.join(os9.homedir(), p.slice(2));
+  if (p.startsWith("~/")) return path12.join(os9.homedir(), p.slice(2));
   return p;
 }
 function globToRegex(glob) {
@@ -16153,7 +16322,7 @@ function shouldIgnore2(name, extraPatterns, includeHidden) {
 }
 function matchesExtensions(filename, extensions) {
   if (!extensions || extensions.length === 0) return true;
-  const ext = path11.extname(filename).toLowerCase();
+  const ext = path12.extname(filename).toLowerCase();
   return extensions.some((e) => {
     const norm = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
     return ext === norm;
@@ -16171,8 +16340,8 @@ async function searchDirectory(dir, pattern, baseDir, options, results) {
     if (results.length >= MAX_RESULTS2) break;
     const { name } = entry;
     if (shouldIgnore2(name, options.excludePatterns, options.includeHidden)) continue;
-    const fullPath = path11.join(dir, name);
-    const relativePath = path11.relative(baseDir, fullPath).split(path11.sep).join("/");
+    const fullPath = path12.join(dir, name);
+    const relativePath = path12.relative(baseDir, fullPath).split(path12.sep).join("/");
     if (entry.isDirectory()) {
       if (pattern.test(name)) {
         results.push({ path: relativePath, type: "directory" });
@@ -16254,7 +16423,7 @@ async function findByName(args) {
 }
 
 // src/app/agent/tools/GrepSearchTool/GrepSearchTool.ts
-import path12 from "path";
+import path13 from "path";
 import { promises as fsPromises2 } from "fs";
 import os10 from "os";
 var MAX_RESULTS3 = 200;
@@ -16344,12 +16513,12 @@ var TEXT_BASENAMES = /* @__PURE__ */ new Set([
 ]);
 function expandTilde3(p) {
   if (p === "~") return os10.homedir();
-  if (p.startsWith("~/")) return path12.join(os10.homedir(), p.slice(2));
+  if (p.startsWith("~/")) return path13.join(os10.homedir(), p.slice(2));
   return p;
 }
 function isTextFile(filepath) {
-  const ext = path12.extname(filepath).toLowerCase();
-  const base = path12.basename(filepath);
+  const ext = path13.extname(filepath).toLowerCase();
+  const base = path13.basename(filepath);
   return TEXT_EXTENSIONS.has(ext) || TEXT_BASENAMES.has(base) || base.startsWith(".") && !ext;
 }
 function shouldIgnore3(name) {
@@ -16386,7 +16555,7 @@ async function searchFile(filepath, baseDir, pattern, contextLines, maxMatchesPe
     if (stat.size > MAX_FILE_SIZE) return null;
     const content = await fsPromises2.readFile(filepath, "utf-8");
     const lines = content.split("\n");
-    const relativePath = path12.relative(baseDir, filepath).split(path12.sep).join("/");
+    const relativePath = path13.relative(baseDir, filepath).split(path13.sep).join("/");
     const matches = [];
     for (let i = 0; i < lines.length && matches.length < maxMatchesPerFile; i++) {
       const line = lines[i];
@@ -16420,7 +16589,7 @@ async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextL
   for (const entry of entries) {
     if (stats.totalMatches >= maxResults) break;
     if (shouldIgnore3(entry.name)) continue;
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path13.join(dir, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, maxResults, maxMatchesPerFile, results, stats);
     } else if (entry.isFile()) {
@@ -16461,7 +16630,7 @@ async function grepSearch(args) {
   });
   if (!query || typeof query !== "string") return empty("query is required");
   if (!searchPath) return empty("path is required");
-  const resolvedPath = path12.resolve(expandTilde3(searchPath));
+  const resolvedPath = path13.resolve(expandTilde3(searchPath));
   const stat = await fsPromises2.stat(resolvedPath).catch(() => null);
   if (!stat) return empty(`Path not found: ${resolvedPath}`);
   let pattern;
@@ -16477,7 +16646,7 @@ async function grepSearch(args) {
       await searchDirectory2(resolvedPath, resolvedPath, pattern, include_patterns, context_lines, max_results, max_matches_per_file, results, stats);
     } else if (stat.isFile()) {
       stats.filesSearched = 1;
-      const fileResult = await searchFile(resolvedPath, path12.dirname(resolvedPath), pattern, context_lines, max_matches_per_file);
+      const fileResult = await searchFile(resolvedPath, path13.dirname(resolvedPath), pattern, context_lines, max_matches_per_file);
       if (fileResult) {
         results.push(fileResult);
         stats.totalMatches = fileResult.match_count;
@@ -16500,7 +16669,7 @@ async function grepSearch(args) {
 }
 
 // src/app/agent/tools/ViewFileOutlineTool/ViewFileOutlineTool.ts
-import path13 from "path";
+import path14 from "path";
 import { promises as fsPromises3 } from "fs";
 var LANGUAGE_MAP = {
   ".ts": "typescript",
@@ -16614,7 +16783,7 @@ var PATTERNS = {
   ]
 };
 function detectLanguage(filepath) {
-  const ext = path13.extname(filepath).toLowerCase();
+  const ext = path14.extname(filepath).toLowerCase();
   return LANGUAGE_MAP[ext] || "unknown";
 }
 function determineItemType(line, language) {
@@ -16710,7 +16879,7 @@ async function viewFileOutline(args) {
         error: "file_path is required and must be a string"
       };
     }
-    const resolvedPath = path13.resolve(file_path);
+    const resolvedPath = path14.resolve(file_path);
     let content;
     try {
       content = await fsPromises3.readFile(resolvedPath, "utf-8");
@@ -16756,21 +16925,21 @@ init_CommandStatusTool();
 // src/app/agent/tools/TaskBoundaryTool/TaskBoundaryTool.ts
 init_sandbox_policy();
 init_task_store();
-import path14 from "path";
-import { promises as fs13 } from "fs";
+import path15 from "path";
+import { promises as fs14 } from "fs";
 var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
   const policy = getSandboxPolicy();
-  const baseDir = path14.join(policy.workspaceRoot, ".bluma", "artifacts");
+  const baseDir = path15.join(policy.workspaceRoot, ".bluma", "artifacts");
   const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
-  artifactsDir = path14.join(baseDir, sessionId);
-  await fs13.mkdir(artifactsDir, { recursive: true });
+  artifactsDir = path15.join(baseDir, sessionId);
+  await fs14.mkdir(artifactsDir, { recursive: true });
   return artifactsDir;
 }
 async function updateTaskFile(task) {
   const dir = await getArtifactsDir();
-  const taskFile = path14.join(dir, "task.md");
+  const taskFile = path15.join(dir, "task.md");
   const content = `# ${task.taskName}
 
         **Mode:** ${task.mode}  
@@ -16782,7 +16951,7 @@ async function updateTaskFile(task) {
         ## Summary
         ${task.summary}
         `;
-  await fs13.writeFile(taskFile, content, "utf-8");
+  await fs14.writeFile(taskFile, content, "utf-8");
 }
 async function taskBoundary(args) {
   try {
@@ -16898,8 +17067,8 @@ async function readArtifact(args) {
       return { success: false, error: "filename is required" };
     }
     const dir = await getArtifactsDir();
-    const filepath = path14.join(dir, filename);
-    const content = await fs13.readFile(filepath, "utf-8");
+    const filepath = path15.join(dir, filename);
+    const content = await fs14.readFile(filepath, "utf-8");
     return {
       success: true,
       content
@@ -17443,8 +17612,8 @@ ${skill.content}`;
 }
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryTool.ts
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
 import os12 from "os";
 var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
 var PROMPT_DEFAULT_MAX_NOTES = 25;
@@ -17453,14 +17622,14 @@ 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 = path15.join(os12.homedir(), ".bluma", "coding_memory.json");
-  const legacyPath = path15.join(process.cwd(), ".bluma", "coding_memory.json");
+  const globalPath = path16.join(os12.homedir(), ".bluma", "coding_memory.json");
+  const legacyPath = path16.join(process.cwd(), ".bluma", "coding_memory.json");
   let raw = null;
   try {
-    if (fs14.existsSync(globalPath)) {
-      raw = fs14.readFileSync(globalPath, "utf-8");
-    } else if (path15.resolve(globalPath) !== path15.resolve(legacyPath) && fs14.existsSync(legacyPath)) {
-      raw = fs14.readFileSync(legacyPath, "utf-8");
+    if (fs15.existsSync(globalPath)) {
+      raw = fs15.readFileSync(globalPath, "utf-8");
+    } else if (path16.resolve(globalPath) !== path16.resolve(legacyPath) && fs15.existsSync(legacyPath)) {
+      raw = fs15.readFileSync(legacyPath, "utf-8");
     }
   } catch {
     return "";
@@ -17498,10 +17667,10 @@ var memoryStore = [];
 var nextId = 1;
 var loaded = false;
 function getMemoryFilePath() {
-  return path15.join(os12.homedir(), ".bluma", "coding_memory.json");
+  return path16.join(os12.homedir(), ".bluma", "coding_memory.json");
 }
 function getLegacyMemoryFilePath() {
-  return path15.join(process.cwd(), ".bluma", "coding_memory.json");
+  return path16.join(process.cwd(), ".bluma", "coding_memory.json");
 }
 function loadMemoryFromFile() {
   if (loaded) return;
@@ -17511,19 +17680,19 @@ function loadMemoryFromFile() {
   try {
     const filePath = getMemoryFilePath();
     const legacy = getLegacyMemoryFilePath();
-    const legacyDistinct = path15.resolve(legacy) !== path15.resolve(filePath);
+    const legacyDistinct = path16.resolve(legacy) !== path16.resolve(filePath);
     const readIntoStore = (p) => {
-      const raw = fs14.readFileSync(p, "utf-8");
+      const raw = fs15.readFileSync(p, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.entries)) {
         memoryStore = parsed.entries;
         nextId = typeof parsed.nextId === "number" ? parsed.nextId : memoryStore.length + 1;
       }
     };
-    if (fs14.existsSync(filePath)) {
+    if (fs15.existsSync(filePath)) {
       readIntoStore(filePath);
     }
-    if (memoryStore.length === 0 && legacyDistinct && fs14.existsSync(legacy)) {
+    if (memoryStore.length === 0 && legacyDistinct && fs15.existsSync(legacy)) {
       readIntoStore(legacy);
       if (memoryStore.length > 0) {
         saveMemoryToFile();
@@ -17537,16 +17706,16 @@ function loadMemoryFromFile() {
 function saveMemoryToFile() {
   try {
     const filePath = getMemoryFilePath();
-    const dir = path15.dirname(filePath);
-    if (!fs14.existsSync(dir)) {
-      fs14.mkdirSync(dir, { recursive: true });
+    const dir = path16.dirname(filePath);
+    if (!fs15.existsSync(dir)) {
+      fs15.mkdirSync(dir, { recursive: true });
     }
     const payload = {
       entries: memoryStore,
       nextId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs14.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+    fs15.writeFileSync(filePath, JSON.stringify(payload, null, 2));
   } catch {
   }
 }
@@ -18048,7 +18217,7 @@ async function cronDelete(args) {
 
 // src/app/agent/tools/NotebookEditTool/NotebookEditTool.ts
 init_sandbox_policy();
-import { promises as fs15 } from "fs";
+import { promises as fs16 } from "fs";
 function sourceToString(s) {
   if (s == null) return "";
   return Array.isArray(s) ? s.join("") : s;
@@ -18060,7 +18229,7 @@ function stringToSource(s) {
 async function applyNotebookOperation(filepath, op) {
   try {
     const resolved = resolveWorkspacePath(filepath);
-    const raw = await fs15.readFile(resolved, "utf-8");
+    const raw = await fs16.readFile(resolved, "utf-8");
     let doc;
     try {
       doc = JSON.parse(raw);
@@ -18101,7 +18270,7 @@ async function applyNotebookOperation(filepath, op) {
         return JSON.stringify({ success: false, error: `cell_index out of range: ${i}` });
       }
       doc.cells[i].source = stringToSource(String(op.source ?? ""));
-      await fs15.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
+      await fs16.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
       return JSON.stringify({ success: true, message: `Updated cell ${i}` });
     }
     if (op.operation === "append_markdown_cell") {
@@ -18110,7 +18279,7 @@ async function applyNotebookOperation(filepath, op) {
         source: stringToSource(String(op.source ?? "")),
         metadata: {}
       });
-      await fs15.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
+      await fs16.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
       return JSON.stringify({ success: true, message: `Appended markdown cell at index ${doc.cells.length - 1}` });
     }
     if (op.operation === "delete_cell") {
@@ -18119,7 +18288,7 @@ async function applyNotebookOperation(filepath, op) {
         return JSON.stringify({ success: false, error: `cell_index out of range: ${i}` });
       }
       doc.cells.splice(i, 1);
-      await fs15.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
+      await fs16.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
       return JSON.stringify({ success: true, message: `Deleted cell ${i}` });
     }
     return JSON.stringify({ success: false, error: "unknown operation" });
@@ -18158,8 +18327,8 @@ async function notebook_edit(args) {
 // src/app/agent/tools/LspQueryTool/LspQueryTool.ts
 init_sandbox_policy();
 import { spawn as spawn3 } from "child_process";
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 import { pathToFileURL } from "url";
 var RpcBuffer = class {
   buf = Buffer.alloc(0);
@@ -18209,12 +18378,12 @@ async function lsp_query(args) {
   } catch (e) {
     return JSON.stringify({ success: false, error: e.message || String(e) });
   }
-  if (!fs16.existsSync(resolved) || !fs16.statSync(resolved).isFile()) {
+  if (!fs17.existsSync(resolved) || !fs17.statSync(resolved).isFile()) {
     return JSON.stringify({ success: false, error: "file not found" });
   }
-  const content = fs16.readFileSync(resolved, "utf-8");
+  const content = fs17.readFileSync(resolved, "utf-8");
   const uri = pathToFileURL(resolved).href;
-  const root = path16.dirname(resolved);
+  const root = path17.dirname(resolved);
   const line0 = Math.max(0, Math.floor(Number(args.line) || 1) - 1);
   const character = Math.max(0, Math.floor(Number(args.character ?? 0)));
   const operation = args.operation === "references" ? "references" : "definition";
@@ -18334,8 +18503,8 @@ async function lsp_query(args) {
 
 // src/app/agent/tools/FileWriteTool/FileWriteTool.ts
 init_sandbox_policy();
-import { promises as fs17 } from "fs";
-import path17 from "path";
+import { promises as fs18 } from "fs";
+import path18 from "path";
 async function fileWrite(args) {
   const {
     filepath,
@@ -18353,10 +18522,10 @@ async function fileWrite(args) {
       return { success: false, error: "content is required" };
     }
     const resolvedPath = resolveWorkspacePath(targetPath);
-    const dir = path17.dirname(resolvedPath);
+    const dir = path18.dirname(resolvedPath);
     let existed = false;
     try {
-      const st = await fs17.stat(resolvedPath);
+      const st = await fs18.stat(resolvedPath);
       existed = st.isFile();
     } catch {
       existed = false;
@@ -18370,15 +18539,15 @@ async function fileWrite(args) {
     let previousContent = "";
     if (existed) {
       try {
-        previousContent = await fs17.readFile(resolvedPath, "utf-8");
+        previousContent = await fs18.readFile(resolvedPath, "utf-8");
       } catch {
         previousContent = "";
       }
     }
     if (create_directories) {
-      await fs17.mkdir(dir, { recursive: true });
+      await fs18.mkdir(dir, { recursive: true });
     }
-    await fs17.writeFile(resolvedPath, String(content), "utf-8");
+    await fs18.writeFile(resolvedPath, String(content), "utf-8");
     const bytes = Buffer.byteLength(String(content), "utf-8");
     return {
       success: true,
@@ -18687,9 +18856,9 @@ async function signalMailbox(args) {
 }
 
 // src/app/agent/tools/ReplTool/ReplTool.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import os17 from "os";
-import path22 from "path";
+import path23 from "path";
 import { exec } from "child_process";
 import { v4 as uuidv47 } from "uuid";
 import { promisify as promisify2 } from "util";
@@ -18701,20 +18870,20 @@ async function repl(params) {
   let tempFile;
   switch (language) {
     case "python": {
-      tempFile = path22.join(os17.tmpdir(), `bluma_repl_${uuidv47()}.py`);
-      fs22.writeFileSync(tempFile, code, "utf-8");
+      tempFile = path23.join(os17.tmpdir(), `bluma_repl_${uuidv47()}.py`);
+      fs23.writeFileSync(tempFile, code, "utf-8");
       command = `python3 "${tempFile}"`;
       break;
     }
     case "node": {
-      tempFile = path22.join(os17.tmpdir(), `bluma_repl_${uuidv47()}.mjs`);
-      fs22.writeFileSync(tempFile, code, "utf-8");
+      tempFile = path23.join(os17.tmpdir(), `bluma_repl_${uuidv47()}.mjs`);
+      fs23.writeFileSync(tempFile, code, "utf-8");
       command = `node "${tempFile}"`;
       break;
     }
     case "bash": {
-      tempFile = path22.join(os17.tmpdir(), `bluma_repl_${uuidv47()}.sh`);
-      fs22.writeFileSync(tempFile, `#!/bin/bash
+      tempFile = path23.join(os17.tmpdir(), `bluma_repl_${uuidv47()}.sh`);
+      fs23.writeFileSync(tempFile, `#!/bin/bash
 set -e
 ${code}`, "utf-8");
       command = `bash "${tempFile}"`;
@@ -18728,7 +18897,7 @@ ${code}`, "utf-8");
       // 5MB
     });
     try {
-      fs22.unlinkSync(tempFile);
+      fs23.unlinkSync(tempFile);
     } catch {
     }
     return {
@@ -18740,7 +18909,7 @@ ${code}`, "utf-8");
     };
   } catch (error) {
     try {
-      fs22.unlinkSync(tempFile);
+      fs23.unlinkSync(tempFile);
     } catch {
     }
     const exitCode = error.code === "ERR_CHILD_PROCESS_TIMEOUT" ? 124 : error.status ?? 1;
@@ -19088,8 +19257,8 @@ ${preview}${toRemove.length > 5 ? `
 
 // src/app/agent/tools/BriefTool/BriefTool.ts
 init_sandbox_policy();
-import * as fs23 from "fs";
-import * as path23 from "path";
+import * as fs24 from "fs";
+import * as path24 from "path";
 async function brief(args) {
   const sentAt = (/* @__PURE__ */ new Date()).toISOString();
   if (!args.message || !args.message.trim()) {
@@ -19108,9 +19277,9 @@ async function brief(args) {
     const resolved = [];
     for (const filePath of args.attachments) {
       try {
-        const absolutePath = path23.isAbsolute(filePath) ? filePath : path23.join(resolveWorkspacePath("."), filePath);
-        if (fs23.existsSync(absolutePath)) {
-          const stat = fs23.statSync(absolutePath);
+        const absolutePath = path24.isAbsolute(filePath) ? filePath : path24.join(resolveWorkspacePath("."), filePath);
+        if (fs24.existsSync(absolutePath)) {
+          const stat = fs24.statSync(absolutePath);
           resolved.push({
             path: absolutePath,
             size: stat.size,
@@ -19149,14 +19318,14 @@ async function brief(args) {
 }
 
 // src/app/agent/tools/DreamEngineTool/DreamEngineTool.ts
-import * as fs24 from "fs";
-import * as path24 from "path";
+import * as fs25 from "fs";
+import * as path25 from "path";
 import os18 from "os";
 function memoryPath() {
-  return path24.join(process.env.HOME || os18.homedir(), ".bluma", "coding_memory.json");
+  return path25.join(process.env.HOME || os18.homedir(), ".bluma", "coding_memory.json");
 }
 function sessionsDir() {
-  return path24.join(process.env.HOME || os18.homedir(), ".bluma", "sessions");
+  return path25.join(process.env.HOME || os18.homedir(), ".bluma", "sessions");
 }
 function normalizeNote(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -19181,9 +19350,9 @@ async function dream(args = {}) {
   const mergeSimilar = args.mergeSimilar !== false;
   const memPath = memoryPath();
   let memData = null;
-  if (fs24.existsSync(memPath)) {
+  if (fs25.existsSync(memPath)) {
     try {
-      memData = JSON.parse(fs24.readFileSync(memPath, "utf-8"));
+      memData = JSON.parse(fs25.readFileSync(memPath, "utf-8"));
     } catch {
     }
   }
@@ -19260,12 +19429,12 @@ async function dream(args = {}) {
     pruned += removed.length;
   }
   const sessDir = sessionsDir();
-  if (fs24.existsSync(sessDir)) {
+  if (fs25.existsSync(sessDir)) {
     try {
-      const sessionFiles = fs24.readdirSync(sessDir).filter((f) => f.endsWith(".json")).slice(-5);
+      const sessionFiles = fs25.readdirSync(sessDir).filter((f) => f.endsWith(".json")).slice(-5);
       for (const sf of sessionFiles) {
         try {
-          const sessionData = JSON.parse(fs24.readFileSync(path24.join(sessDir, sf), "utf-8"));
+          const sessionData = JSON.parse(fs25.readFileSync(path25.join(sessDir, sf), "utf-8"));
           if (sessionData?.summary) {
             consolidatedMemories.push(`Session ${sf}: ${sessionData.summary}`);
           }
@@ -19280,7 +19449,7 @@ async function dream(args = {}) {
     memData.nextId = entries.reduce((max, e) => Math.max(max, e.id || 0), 0) + 1;
     memData.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     try {
-      fs24.writeFileSync(memPath, JSON.stringify(memData, null, 2), "utf-8");
+      fs25.writeFileSync(memPath, JSON.stringify(memData, null, 2), "utf-8");
     } catch (e) {
       return {
         success: false,
@@ -19473,8 +19642,8 @@ async function context_collapse(args = {}) {
 
 // src/app/agent/tools/CreateNextAppTool/CreateNextAppTool.ts
 init_sandbox_policy();
-import { promises as fs25 } from "fs";
-import path25 from "path";
+import { promises as fs26 } from "fs";
+import path26 from "path";
 
 // src/app/agent/tools/ShellCommandTool/ShellCommandTool.ts
 init_sandbox_policy();
@@ -20248,10 +20417,10 @@ export function cn(...inputs: ClassValue[]) {
 `
 };
 async function createFile(filePath, content, projectName) {
-  const dir = path25.dirname(filePath);
-  await fs25.mkdir(dir, { recursive: true });
+  const dir = path26.dirname(filePath);
+  await fs26.mkdir(dir, { recursive: true });
   const replacedContent = content.replace(/{{NAME}}/g, projectName);
-  await fs25.writeFile(filePath, replacedContent, "utf-8");
+  await fs26.writeFile(filePath, replacedContent, "utf-8");
 }
 async function createNextApp(args) {
   const {
@@ -20270,26 +20439,26 @@ async function createNextApp(args) {
       };
     }
     const baseDir = directory ? resolveWorkspacePath(directory) : resolveWorkspacePath(".");
-    const projectPath = path25.join(baseDir, name);
+    const projectPath = path26.join(baseDir, name);
     try {
-      await fs25.access(projectPath);
+      await fs26.access(projectPath);
       return {
         success: false,
         error: `Directory already exists: ${projectPath}. Remove it first or choose a different name.`
       };
     } catch {
     }
-    await fs25.mkdir(projectPath, { recursive: true });
+    await fs26.mkdir(projectPath, { recursive: true });
     const filesToCreate = template === "minimal" ? MINIMAL_FILES : FULL_FILES;
     const filesCreated = [];
     for (const [relativePath, content] of Object.entries(filesToCreate)) {
       if (relativePath === "package.json.full") continue;
-      const fullPath = path25.join(projectPath, relativePath);
+      const fullPath = path26.join(projectPath, relativePath);
       await createFile(fullPath, content, name);
       filesCreated.push(relativePath);
     }
     if (template === "full") {
-      const packageJsonPath = path25.join(projectPath, "package.json");
+      const packageJsonPath = path26.join(projectPath, "package.json");
       const fullPackageJson = FULL_FILES["package.json.full"];
       if (fullPackageJson) {
         await createFile(packageJsonPath, fullPackageJson, name);
@@ -20331,8 +20500,8 @@ async function createNextApp(args) {
 
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 init_sandbox_policy();
-import { promises as fs26 } from "fs";
-import path26 from "path";
+import { promises as fs27 } from "fs";
+import path27 from "path";
 var EXCLUDE_PATTERNS = [
   "node_modules",
   ".next",
@@ -20482,8 +20651,8 @@ function buildFactorAiManifest(appContext, deployResult, appName) {
 }
 async function writeFactorAiManifest(projectDir, appContext, deployResult, appName) {
   const manifest = buildFactorAiManifest(appContext, deployResult, appName);
-  const manifestPath = path26.join(projectDir, "factorai.sh.json");
-  await fs26.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = path27.join(projectDir, "factorai.sh.json");
+  await fs27.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   return manifest;
 }
@@ -20503,23 +20672,23 @@ async function deployApp(args) {
     }
     const resolvedProjectDir = resolveWorkspacePath(projectDir);
     try {
-      await fs26.access(resolvedProjectDir);
+      await fs27.access(resolvedProjectDir);
     } catch {
       return {
         success: false,
         error: `Project directory not found: ${resolvedProjectDir}`
       };
     }
-    const packageJsonPath = path26.join(resolvedProjectDir, "package.json");
+    const packageJsonPath = path27.join(resolvedProjectDir, "package.json");
     try {
-      await fs26.access(packageJsonPath);
+      await fs27.access(packageJsonPath);
     } catch {
       return {
         success: false,
         error: "Not a Next.js project: package.json not found"
       };
     }
-    const packageJsonContent = await fs26.readFile(packageJsonPath, "utf-8");
+    const packageJsonContent = await fs27.readFile(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     const hasNext = packageJson.dependencies?.next || packageJson.devDependencies?.next;
     if (!hasNext) {
@@ -20528,18 +20697,18 @@ async function deployApp(args) {
         error: "Not a Next.js project: next not found in dependencies"
       };
     }
-    const appName = name || packageJson.name || path26.basename(resolvedProjectDir);
-    const tempDir = path26.join(resolvedProjectDir, ".tmp");
-    await fs26.mkdir(tempDir, { recursive: true });
-    const zipPath = path26.join(tempDir, `${appName}-${Date.now()}.zip`);
+    const appName = name || packageJson.name || path27.basename(resolvedProjectDir);
+    const tempDir = path27.join(resolvedProjectDir, ".tmp");
+    await fs27.mkdir(tempDir, { recursive: true });
+    const zipPath = path27.join(tempDir, `${appName}-${Date.now()}.zip`);
     console.log(`[deploy-app] Creating ZIP: ${zipPath}`);
     await createProjectZip(resolvedProjectDir, zipPath);
-    const zipStats = await fs26.stat(zipPath);
+    const zipStats = await fs27.stat(zipPath);
     const zipSizeMB = zipStats.size / 1024 / 1024;
     if (zipSizeMB > 50) {
-      await fs26.unlink(zipPath).catch(() => {
+      await fs27.unlink(zipPath).catch(() => {
       });
-      await fs26.rmdir(tempDir).catch(() => {
+      await fs27.rmdir(tempDir).catch(() => {
       });
       return {
         success: false,
@@ -20550,8 +20719,8 @@ async function deployApp(args) {
     console.log(`[deploy-app] Uploading to ${severinoUrl}...`);
     const deployResult = await uploadToSeverino(zipPath, severinoUrl, appName, apiKey, appId);
     try {
-      await fs26.unlink(zipPath);
-      await fs26.rmdir(tempDir);
+      await fs27.unlink(zipPath);
+      await fs27.rmdir(tempDir);
     } catch (e) {
       console.warn("[deploy-app] Cleanup warning:", e);
     }
@@ -20564,7 +20733,7 @@ async function deployApp(args) {
           appName
         );
         deployResult.factoraiManifest = manifest;
-        deployResult.factoraiManifestPath = path26.join(resolvedProjectDir, "factorai.sh.json");
+        deployResult.factoraiManifestPath = path27.join(resolvedProjectDir, "factorai.sh.json");
       }
       console.log(`[deploy-app] Deploy iniciado: ${deployResult.appId}`);
     }
@@ -20579,8 +20748,8 @@ async function deployApp(args) {
 }
 
 // src/app/agent/runtime/factorai_context.ts
-import fs27 from "fs";
-import path27 from "path";
+import fs28 from "fs";
+import path28 from "path";
 function normalizeContext(raw) {
   if (!raw || typeof raw.appId !== "string" || !raw.appId.trim()) {
     return null;
@@ -20601,10 +20770,10 @@ function normalizeContext(raw) {
 }
 function readJsonFile(filePath) {
   try {
-    if (!fs27.existsSync(filePath)) {
+    if (!fs28.existsSync(filePath)) {
       return null;
     }
-    const parsed = JSON.parse(fs27.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs28.readFileSync(filePath, "utf8"));
     if (parsed && typeof parsed === "object") {
       return parsed.appContext && typeof parsed.appContext === "object" ? parsed.appContext : parsed;
     }
@@ -20614,19 +20783,19 @@ function readJsonFile(filePath) {
   return null;
 }
 function readFactorAiWorkspaceManifest(projectDir = process.cwd()) {
-  const manifestPath = path27.join(projectDir, "factorai.sh.json");
+  const manifestPath = path28.join(projectDir, "factorai.sh.json");
   try {
-    if (!fs27.existsSync(manifestPath)) {
+    if (!fs28.existsSync(manifestPath)) {
       return null;
     }
-    const parsed = JSON.parse(fs27.readFileSync(manifestPath, "utf8"));
+    const parsed = JSON.parse(fs28.readFileSync(manifestPath, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
   }
 }
 function readContextFromWorkspace() {
-  const candidate = path27.join(process.cwd(), "factorai.sh.json");
+  const candidate = path28.join(process.cwd(), "factorai.sh.json");
   const parsed = readJsonFile(candidate);
   if (!parsed) {
     return null;
@@ -20713,8 +20882,8 @@ function buildFactorAiWorkspaceManifest(input) {
 async function writeFactorAiWorkspaceManifest(input) {
   const projectDir = input.projectDir || process.cwd();
   const manifest = buildFactorAiWorkspaceManifest({ ...input, projectDir });
-  const manifestPath = path27.join(projectDir, "factorai.sh.json");
-  fs27.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = path28.join(projectDir, "factorai.sh.json");
+  fs28.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return { manifestPath, manifest };
 }
@@ -20970,7 +21139,7 @@ var NATIVE_TOOL_ENTRIES = [
       autoApproveInLocal: true,
       autoApproveInSandbox: true,
       sandboxOnly: true,
-      description: 'Primary channel \u2014 use generously. message_type "info": call frequently (good UX expects multiple per turn; does not stop the turn). message_type "result": once to end the turn.'
+      description: 'Primary channel \u2014 use generously. message_type "info": progress only (does not stop the turn). message_type "result": ends the turn; in sandbox, file deliverables MUST use attachments[] with paths under .bluma/artifacts/ (content alone does not deliver files).'
     },
     implementation: message
   },
@@ -21596,9 +21765,18 @@ function getNativeToolMetadata(toolName) {
 function getNativeToolImplementation(toolName) {
   return TOOL_IMPLEMENTATION_MAP.get(toolName);
 }
+function isFactorAiToolName(toolName) {
+  return toolName.startsWith("factorai.sh.");
+}
 function shouldExposeToolEntry(entry, policy = getSandboxPolicy()) {
-  if (entry.metadata.sandboxOnly && !isFactorAiSandboxEnabled()) {
-    return false;
+  if (entry.metadata.sandboxOnly) {
+    if (isFactorAiToolName(entry.metadata.name)) {
+      if (!isFactorAiSandboxEnabled()) {
+        return false;
+      }
+    } else if (!policy.isSandbox) {
+      return false;
+    }
   }
   if (entry.metadata.hiddenInSandbox && policy.isSandbox) {
     return false;
@@ -21612,8 +21790,41 @@ function getAllNativeToolMetadata() {
   const policy = getSandboxPolicy();
   return NATIVE_TOOL_ENTRIES.filter((entry) => shouldExposeToolEntry(entry, policy)).map((entry) => entry.metadata);
 }
+var SANDBOX_COMMUNICATION_TOOL_DEFINITIONS = [
+  {
+    type: "function",
+    function: {
+      name: "message",
+      description: 'Deliver user-visible output. message_type "info": progress (does not end turn). message_type "result": ends turn; file deliverables MUST use attachments[] with paths under .bluma/artifacts/.',
+      parameters: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "Markdown body shown to the user." },
+          message_type: {
+            type: "string",
+            enum: ["info", "result"],
+            description: "info = progress; result = final delivery (ends turn in sandbox)."
+          },
+          attachments: {
+            type: "array",
+            items: { type: "string" },
+            description: "Workspace file paths under .bluma/artifacts/ (required for file deliverables on result)."
+          }
+        },
+        required: ["content", "message_type"],
+        additionalProperties: false
+      }
+    }
+  }
+];
+function getSandboxCommunicationToolDefinitions() {
+  if (!getSandboxPolicy().isSandbox) {
+    return [];
+  }
+  return SANDBOX_COMMUNICATION_TOOL_DEFINITIONS;
+}
 function getSandboxOnlyNativeToolDefinitions() {
-  return getFactorAiSandboxToolDefinitions();
+  return [...getSandboxCommunicationToolDefinitions(), ...getFactorAiSandboxToolDefinitions()];
 }
 function applyMetadataToToolDefinitions(toolDefinitions) {
   return toolDefinitions.map((definition) => {
@@ -21709,6 +21920,24 @@ function toolResultToString(value) {
   const result = normalizeToolResult(value);
   return JSON.stringify(result, null, 2);
 }
+function extractMessageToolPayload(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const root = parsed;
+  if (root.status === "error") {
+    return { status: "error", message_type: void 0 };
+  }
+  const data = root.data && typeof root.data === "object" && !Array.isArray(root.data) ? root.data : root;
+  if (typeof data.message_type === "string") {
+    return { message_type: data.message_type, status: typeof root.status === "string" ? root.status : void 0 };
+  }
+  return null;
+}
+function isMessageToolResultTerminal(parsed) {
+  const payload = extractMessageToolPayload(parsed);
+  return payload?.message_type === "result" && payload.status !== "error";
+}
 
 // src/app/agent/tool_invoker.ts
 var ToolInvoker = class {
@@ -21723,9 +21952,9 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const currentFilePath = fileURLToPath3(import.meta.url);
-      const currentDirPath = path28.dirname(currentFilePath);
-      const configPath = path28.resolve(currentDirPath, "config", "native_tools.json");
-      const fileContent = await fs28.readFile(configPath, "utf-8");
+      const currentDirPath = path29.dirname(currentFilePath);
+      const configPath = path29.resolve(currentDirPath, "config", "native_tools.json");
+      const fileContent = await fs29.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = applyMetadataToToolDefinitions(config2.nativeTools);
       const sandboxOnlyTools = applyMetadataToToolDefinitions(getSandboxOnlyNativeToolDefinitions());
@@ -21772,8 +22001,8 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs29 } from "fs";
-import path29 from "path";
+import { promises as fs30 } from "fs";
+import path30 from "path";
 import os20 from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -21801,9 +22030,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath4(import.meta.url);
-    const __dirname2 = path29.dirname(__filename);
-    const defaultConfigPath = path29.resolve(__dirname2, "config", "bluma-mcp.json");
-    const userConfigPath = path29.join(os20.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname2 = path30.dirname(__filename);
+    const defaultConfigPath = path30.resolve(__dirname2, "config", "bluma-mcp.json");
+    const userConfigPath = path30.join(os20.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -21837,7 +22066,7 @@ var MCPClient = class {
   }
   async loadMcpConfig(configPath, configType) {
     try {
-      const fileContent = await fs29.readFile(configPath, "utf-8");
+      const fileContent = await fs30.readFile(configPath, "utf-8");
       const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
@@ -21894,11 +22123,14 @@ var MCPClient = class {
     }
   }
   async invoke(toolName, args) {
-    const route = this.toolToServerMap.get(toolName);
+    let route = this.toolToServerMap.get(toolName);
+    if (!route && getNativeToolImplementation(toolName)) {
+      route = { server: "native", originalName: toolName };
+    }
     if (!route) {
       return {
         status: "error",
-        error: `This tool '${toolName}'is not found or registered you must use the correct name of this tool.`
+        error: `This tool '${toolName}' is not found or registered. You must use the correct name from the available tools list.`
       };
     }
     if (route.server === "native") {
@@ -22031,7 +22263,7 @@ You streamed or returned **user-visible markdown as assistant content** instead
 
 Do this **immediately** in your next step (single tool call, no prose outside tools):
 
-- Call **\`message\`** with **\`message_type\`: \`"result"\`**, put the user-facing summary in **\`content\`**, and put deliverable paths in **\`attachments\`** (absolute paths).
+- Call **\`message\`** with **\`message_type\`: \`"result"\`**, summary in **\`content\`**, and every file path in **\`attachments\`** under **\`.bluma/artifacts/\`** (this is the only delivery channel for files).
 
 Do **not** repeat the same summary as plain assistant text again.
 PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
@@ -22046,14 +22278,14 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path40 from "path";
-import fs39 from "fs";
+import path41 from "path";
+import fs40 from "fs";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path30 from "path";
+import path31 from "path";
 import os21 from "os";
-import { promises as fs30 } from "fs";
+import { promises as fs31 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -22089,13 +22321,13 @@ function debouncedSave(sessionFile, history, memory) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path30.join(os21.homedir(), p.slice(1));
+    return path31.join(os21.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path30.join(os21.homedir(), ".bluma");
-  return path30.resolve(expandHome(fixed));
+  const fixed = path31.join(os21.homedir(), ".bluma");
+  return path31.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -22103,10 +22335,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path30.dirname(dest);
-      await fs30.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path31.dirname(dest);
+      await fs31.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs30.rename(src, dest);
+      await fs31.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -22119,13 +22351,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs30.access(src);
-    const data = await fs30.readFile(src);
-    const dir = path30.dirname(dest);
-    await fs30.mkdir(dir, { recursive: true }).catch(() => {
+    await fs31.access(src);
+    const data = await fs31.readFile(src);
+    const dir = path31.dirname(dest);
+    await fs31.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs30.writeFile(dest, data);
-    await fs30.unlink(src).catch(() => {
+    await fs31.writeFile(dest, data);
+    await fs31.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -22138,16 +22370,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path30.join(appDir, "sessions");
-  await fs30.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path31.join(appDir, "sessions");
+  await fs31.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadSession(sessionId) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path30.join(sessionDir, `${sessionId}.json`);
+  const sessionFile = path31.join(sessionDir, `${sessionId}.json`);
   try {
-    await fs30.access(sessionFile);
-    const fileContent = await fs30.readFile(sessionFile, "utf-8");
+    await fs31.access(sessionFile);
+    const fileContent = await fs31.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     const memory = {
       historyAnchor: sessionData.history_anchor ?? null,
@@ -22164,13 +22396,13 @@ async function loadOrcreateSession(sessionId) {
     return existing;
   }
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path30.join(sessionDir, `${sessionId}.json`);
+  const sessionFile = path31.join(sessionDir, `${sessionId}.json`);
   const newSessionData = {
     session_id: sessionId,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     conversation_history: []
   };
-  await fs30.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+  await fs31.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
   const emptyMemory = {
     historyAnchor: null,
     compressedTurnSliceCount: 0
@@ -22181,12 +22413,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path30.dirname(sessionFile);
-      await fs30.mkdir(dir, { recursive: true });
+      const dir = path31.dirname(sessionFile);
+      await fs31.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs30.readFile(sessionFile, "utf-8");
+      const fileContent = await fs31.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -22197,14 +22429,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path30.basename(sessionFile, ".json");
+      const sessionId = path31.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs30.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs31.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -22220,7 +22452,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     }
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs30.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs31.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -22229,7 +22461,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs30.unlink(tempSessionFile);
+        await fs31.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -22247,13 +22479,13 @@ async function saveSessionHistory(sessionFile, history, memory) {
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os26 from "os";
-import fs37 from "fs";
-import path37 from "path";
+import fs38 from "fs";
+import path38 from "path";
 import { execSync as execSync4 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs31 from "fs";
-import path31 from "path";
+import fs32 from "fs";
+import path32 from "path";
 import os22 from "os";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 var SkillLoader = class _SkillLoader {
@@ -22263,8 +22495,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path31.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path31.join(os22.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path32.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path32.join(os22.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -22273,48 +22505,48 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path31.join(process.cwd(), "dist", "config", "skills");
+      return path32.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path31.resolve(p);
+      const abs = path32.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path31.dirname(fileURLToPath5(import.meta.url));
-      push(path31.join(bundleDir, "config", "skills"));
+      const bundleDir = path32.dirname(fileURLToPath5(import.meta.url));
+      push(path32.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path31.isAbsolute(argv1) && fs31.existsSync(argv1)) {
-          resolved = fs31.realpathSync(argv1);
-        } else if (!path31.isAbsolute(argv1)) {
-          resolved = path31.resolve(process.cwd(), argv1);
+        if (path32.isAbsolute(argv1) && fs32.existsSync(argv1)) {
+          resolved = fs32.realpathSync(argv1);
+        } else if (!path32.isAbsolute(argv1)) {
+          resolved = path32.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path31.dirname(resolved);
-        argvBundled = path31.join(scriptDir, "config", "skills");
+        const scriptDir = path32.dirname(resolved);
+        argvBundled = path32.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
     }
     for (const abs of candidates) {
-      if (fs31.existsSync(abs)) {
+      if (fs32.existsSync(abs)) {
         return abs;
       }
     }
     try {
-      return path31.join(path31.dirname(fileURLToPath5(import.meta.url)), "config", "skills");
+      return path32.join(path32.dirname(fileURLToPath5(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path31.join(os22.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path32.join(os22.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -22343,8 +22575,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path31.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path31.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path32.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path32.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -22352,20 +22584,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs31.existsSync(dir)) return [];
+    if (!fs32.existsSync(dir)) return [];
     try {
-      return fs31.readdirSync(dir).filter((d) => {
-        const fullPath = path31.join(dir, d);
-        return fs31.statSync(fullPath).isDirectory() && fs31.existsSync(path31.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path31.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs32.readdirSync(dir).filter((d) => {
+        const fullPath = path32.join(dir, d);
+        return fs32.statSync(fullPath).isDirectory() && fs32.existsSync(path32.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path32.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs31.existsSync(skillPath)) return null;
+    if (!fs32.existsSync(skillPath)) return null;
     try {
-      const raw = fs31.readFileSync(skillPath, "utf-8");
+      const raw = fs32.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -22387,12 +22619,12 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path31.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path31.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path31.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs31.existsSync(bundledPath);
-    const existsProject = fs31.existsSync(projectPath);
-    const existsGlobal = fs31.existsSync(globalPath);
+    const bundledPath = path32.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path32.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path32.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs32.existsSync(bundledPath);
+    const existsProject = fs32.existsSync(projectPath);
+    const existsGlobal = fs32.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -22431,9 +22663,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs31.readFileSync(skillPath, "utf-8");
+      const raw = fs32.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path31.dirname(skillPath);
+      const skillDir = path32.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -22442,22 +22674,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path31.join(skillDir, "references")),
-        scripts: this.scanAssets(path31.join(skillDir, "scripts"))
+        references: this.scanAssets(path32.join(skillDir, "references")),
+        scripts: this.scanAssets(path32.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs31.existsSync(dir)) return [];
+    if (!fs32.existsSync(dir)) return [];
     try {
-      return fs31.readdirSync(dir).filter((f) => {
-        const fp = path31.join(dir, f);
-        return fs31.statSync(fp).isFile();
+      return fs32.readdirSync(dir).filter((f) => {
+        const fp = path32.join(dir, f);
+        return fs32.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path31.resolve(dir, f)
+        path: path32.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -22514,10 +22746,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path31.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path31.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path31.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs31.existsSync(bundledPath) || fs31.existsSync(projectPath) || fs31.existsSync(globalPath);
+    const bundledPath = path32.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path32.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path32.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs32.existsSync(bundledPath) || fs32.existsSync(projectPath) || fs32.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -22549,13 +22781,13 @@ var SkillLoader = class _SkillLoader {
 };
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
-import fs33 from "fs";
-import path33 from "path";
+import fs34 from "fs";
+import path34 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/utils/blumamd.ts
-import fs32 from "fs";
-import path32 from "path";
+import fs33 from "fs";
+import path33 from "path";
 import os23 from "os";
 import { execSync as execSync2 } from "child_process";
 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.";
@@ -22685,12 +22917,12 @@ var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 function expandIncludePath(includePath, baseDir) {
   const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
   if (cleanPath.startsWith("~")) {
-    return path32.join(os23.homedir(), cleanPath.slice(1));
+    return path33.join(os23.homedir(), cleanPath.slice(1));
   }
-  if (path32.isAbsolute(cleanPath)) {
+  if (path33.isAbsolute(cleanPath)) {
     return cleanPath;
   }
-  return path32.resolve(baseDir, cleanPath);
+  return path33.resolve(baseDir, cleanPath);
 }
 function processIncludes(content, baseDir, processedFiles) {
   const lines = content.split("\n");
@@ -22699,20 +22931,20 @@ function processIncludes(content, baseDir, processedFiles) {
     const includeMatch = line.match(/^@\s*([^\s]+)/);
     if (includeMatch) {
       const includePath = expandIncludePath(includeMatch[1], baseDir);
-      const normalizedPath = path32.normalize(includePath);
+      const normalizedPath = path33.normalize(includePath);
       if (processedFiles.has(normalizedPath)) {
         result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
         continue;
       }
-      const ext = path32.extname(includePath).toLowerCase();
+      const ext = path33.extname(includePath).toLowerCase();
       if (!TEXT_FILE_EXTENSIONS.has(ext)) {
         result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
         continue;
       }
       try {
-        const includedContent = fs32.readFileSync(includePath, "utf-8");
+        const includedContent = fs33.readFileSync(includePath, "utf-8");
         processedFiles.add(normalizedPath);
-        const processedContent = processIncludes(includedContent, path32.dirname(includePath), processedFiles);
+        const processedContent = processIncludes(includedContent, path33.dirname(includePath), processedFiles);
         result.push(`
 <!-- BEGIN INCLUDE ${includeMatch[1]} -->
 `);
@@ -22758,9 +22990,9 @@ function parseFrontmatterPaths(paths2) {
 }
 function readMemoryFile(filePath, type, includeBasePath) {
   try {
-    const rawContent = fs32.readFileSync(filePath, "utf-8");
-    const baseDir = includeBasePath || path32.dirname(filePath);
-    const processedFiles = /* @__PURE__ */ new Set([path32.normalize(filePath)]);
+    const rawContent = fs33.readFileSync(filePath, "utf-8");
+    const baseDir = includeBasePath || path33.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path33.normalize(filePath)]);
     const { frontmatter, content: withoutFrontmatter } = parseFrontmatter(rawContent);
     const globs = parseFrontmatterPaths(frontmatter.paths);
     const processedContent = processIncludes(withoutFrontmatter, baseDir, processedFiles);
@@ -22782,15 +23014,15 @@ function readMemoryFile(filePath, type, includeBasePath) {
 }
 function findGitRoot(startDir) {
   let current = startDir;
-  while (current !== path32.dirname(current)) {
-    const gitPath = path32.join(current, ".git");
+  while (current !== path33.dirname(current)) {
+    const gitPath = path33.join(current, ".git");
     try {
-      if (fs32.existsSync(gitPath)) {
+      if (fs33.existsSync(gitPath)) {
         return current;
       }
     } catch {
     }
-    current = path32.dirname(current);
+    current = path33.dirname(current);
   }
   return null;
 }
@@ -22815,17 +23047,17 @@ function getGitUserInfo(cwd2) {
 }
 function processRulesDirectory(rulesDir, type, processedPaths, conditionalRule = false) {
   const result = [];
-  if (!fs32.existsSync(rulesDir)) {
+  if (!fs33.existsSync(rulesDir)) {
     return result;
   }
   try {
-    const entries = fs32.readdirSync(rulesDir, { withFileTypes: true });
+    const entries = fs33.readdirSync(rulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path32.join(rulesDir, entry.name);
+      const entryPath = path33.join(rulesDir, entry.name);
       if (entry.isDirectory()) {
         result.push(...processRulesDirectory(entryPath, type, processedPaths, conditionalRule));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const normalizedPath = path32.normalize(entryPath);
+        const normalizedPath = path33.normalize(entryPath);
         if (processedPaths.has(normalizedPath)) {
           continue;
         }
@@ -22861,13 +23093,13 @@ function loadManagedMemory() {
 function loadUserMemory() {
   const files = [];
   const homeDir = os23.homedir();
-  const userBlumaDir = path32.join(homeDir, ".bluma");
-  const userBlumaMd = path32.join(userBlumaDir, "BLUMA.md");
+  const userBlumaDir = path33.join(homeDir, ".bluma");
+  const userBlumaMd = path33.join(userBlumaDir, "BLUMA.md");
   const userFile = readMemoryFile(userBlumaMd, "User");
   if (userFile && userFile.content.trim()) {
     files.push(userFile);
   }
-  const userRulesDir = path32.join(userBlumaDir, "rules");
+  const userRulesDir = path33.join(userBlumaDir, "rules");
   const processedPaths = /* @__PURE__ */ new Set();
   files.push(...processRulesDirectory(userRulesDir, "User", processedPaths, false));
   return files;
@@ -22879,10 +23111,10 @@ function loadProjectMemory(cwd2) {
   let currentDir = cwd2;
   const MAX_TRAVERSAL_DEPTH = 20;
   let depth = 0;
-  const normalizedGitRoot = path32.resolve(gitRoot);
-  while (currentDir !== path32.dirname(currentDir) && path32.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
+  const normalizedGitRoot = path33.resolve(gitRoot);
+  while (currentDir !== path33.dirname(currentDir) && path33.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
     dirs.push(currentDir);
-    currentDir = path32.dirname(currentDir);
+    currentDir = path33.dirname(currentDir);
     depth++;
   }
   if (!dirs.includes(gitRoot)) {
@@ -22890,7 +23122,7 @@ function loadProjectMemory(cwd2) {
   }
   const processedPaths = /* @__PURE__ */ new Set();
   for (const dir of dirs.reverse()) {
-    const projectBlumaMd = path32.join(dir, "BLUMA.md");
+    const projectBlumaMd = path33.join(dir, "BLUMA.md");
     if (!processedPaths.has(projectBlumaMd)) {
       processedPaths.add(projectBlumaMd);
       const projectFile = readMemoryFile(projectBlumaMd, "Project");
@@ -22898,7 +23130,7 @@ function loadProjectMemory(cwd2) {
         files.push(projectFile);
       }
     }
-    const blumaDirBlumaMd = path32.join(dir, ".bluma", "BLUMA.md");
+    const blumaDirBlumaMd = path33.join(dir, ".bluma", "BLUMA.md");
     if (!processedPaths.has(blumaDirBlumaMd)) {
       processedPaths.add(blumaDirBlumaMd);
       const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "Project");
@@ -22906,10 +23138,10 @@ function loadProjectMemory(cwd2) {
         files.push(blumaDirFile);
       }
     }
-    const rulesDir = path32.join(dir, ".bluma", "rules");
+    const rulesDir = path33.join(dir, ".bluma", "rules");
     files.push(...processRulesDirectory(rulesDir, "Project", processedPaths, false));
   }
-  const localBlumaMd = path32.join(cwd2, "BLUMA.local.md");
+  const localBlumaMd = path33.join(cwd2, "BLUMA.local.md");
   if (!processedPaths.has(localBlumaMd)) {
     processedPaths.add(localBlumaMd);
     const localFile = readMemoryFile(localBlumaMd, "Local");
@@ -22995,10 +23227,10 @@ var LIMITS = {
 };
 function safeReadFile(filePath, maxChars) {
   try {
-    if (!fs33.existsSync(filePath)) return null;
-    const st = fs33.statSync(filePath);
+    if (!fs34.existsSync(filePath)) return null;
+    const st = fs34.statSync(filePath);
     if (!st.isFile()) return null;
-    const raw = fs33.readFileSync(filePath, "utf8");
+    const raw = fs34.readFileSync(filePath, "utf8");
     if (raw.includes("\0")) return null;
     if (raw.length <= maxChars) return raw;
     return `${raw.slice(0, maxChars)}
@@ -23010,7 +23242,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd2) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path33.join(cwd2, name), LIMITS.readme);
+    const c = safeReadFile(path34.join(cwd2, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -23018,14 +23250,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd2) {
   const paths2 = [
-    path33.join(cwd2, "BluMa.md"),
-    path33.join(cwd2, "BLUMA.md"),
-    path33.join(cwd2, ".bluma", "BluMa.md")
+    path34.join(cwd2, "BluMa.md"),
+    path34.join(cwd2, "BLUMA.md"),
+    path34.join(cwd2, ".bluma", "BluMa.md")
   ];
   for (const p of paths2) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path33.relative(cwd2, p) || p;
+      const rel = path34.relative(cwd2, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -23033,10 +23265,10 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd2) {
-  const p = path33.join(cwd2, "package.json");
+  const p = path34.join(cwd2, "package.json");
   try {
-    if (!fs33.existsSync(p)) return null;
-    const pkg = JSON.parse(fs33.readFileSync(p, "utf8"));
+    if (!fs34.existsSync(p)) return null;
+    const pkg = JSON.parse(fs34.readFileSync(p, "utf8"));
     const scripts = pkg.scripts;
     let scriptKeys = "";
     if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
@@ -23069,7 +23301,7 @@ function summarizePackageJson(cwd2) {
 }
 function topLevelListing(cwd2) {
   try {
-    const names = fs33.readdirSync(cwd2, { withFileTypes: true });
+    const names = fs34.readdirSync(cwd2, { withFileTypes: true });
     const sorted = [...names].sort((a, b) => a.name.localeCompare(b.name));
     const limited = sorted.slice(0, LIMITS.topDirEntries);
     const lines = limited.map((d) => `${d.name}${d.isDirectory() ? "/" : ""}`);
@@ -23127,7 +23359,7 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path33.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path34.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -23145,15 +23377,15 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path33.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path34.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path33.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path34.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path33.join(cwd2, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path34.join(cwd2, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -23189,14 +23421,14 @@ function buildWorkspaceSnapshot(cwd2) {
   } else {
     parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
   }
-  const tsconfig = safeReadFile(path33.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
+  const tsconfig = safeReadFile(path34.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
   if (tsconfig) {
     parts.push("### tsconfig.json (excerpt)\n```json");
     parts.push(tsconfig);
     parts.push("```\n");
   }
   for (const name of ["Dockerfile", "dockerfile", "Dockerfile.prod", "Dockerfile.dev"]) {
-    const df = safeReadFile(path33.join(cwd2, name), LIMITS.dockerfile);
+    const df = safeReadFile(path34.join(cwd2, name), LIMITS.dockerfile);
     if (df) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -23206,7 +23438,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const dc = safeReadFile(path33.join(cwd2, name), LIMITS.dockerfile);
+    const dc = safeReadFile(path34.join(cwd2, name), LIMITS.dockerfile);
     if (dc) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -23221,12 +23453,12 @@ function buildWorkspaceSnapshot(cwd2) {
     ".circleci/config.yml",
     "Jenkinsfile"
   ]) {
-    const ciFile = path33.join(cwd2, ciPath);
-    if (fs33.existsSync(ciFile)) {
-      const st = fs33.statSync(ciFile);
+    const ciFile = path34.join(cwd2, ciPath);
+    if (fs34.existsSync(ciFile)) {
+      const st = fs34.statSync(ciFile);
       if (st.isDirectory()) {
         try {
-          const wfFiles = fs33.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+          const wfFiles = fs34.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
           if (wfFiles.length > 0) {
             parts.push(`### GitHub Actions workflows
 \`${wfFiles.join("`, `")}\`
@@ -23237,7 +23469,7 @@ function buildWorkspaceSnapshot(cwd2) {
       } else {
         const ci = safeReadFile(ciFile, LIMITS.ciConfig);
         if (ci) {
-          parts.push(`### CI config (${path33.basename(ciPath)})
+          parts.push(`### CI config (${path34.basename(ciPath)})
 `);
           parts.push(ci);
           parts.push("\n");
@@ -23246,8 +23478,8 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const depFile of ["requirements.txt", "Pipfile", "poetry.lock", "Gemfile", "go.sum", "Cargo.lock"]) {
-    const depPath = path33.join(cwd2, depFile);
-    if (fs33.existsSync(depPath)) {
+    const depPath = path34.join(cwd2, depFile);
+    if (fs34.existsSync(depPath)) {
       const depContent = safeReadFile(depPath, 1500);
       if (depContent) {
         parts.push(`### ${depFile} (top entries)
@@ -23260,10 +23492,10 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
-    const envPath = path33.join(cwd2, envFile);
-    if (fs33.existsSync(envPath)) {
+    const envPath = path34.join(cwd2, envFile);
+    if (fs34.existsSync(envPath)) {
       try {
-        const raw = fs33.readFileSync(envPath, "utf-8");
+        const raw = fs34.readFileSync(envPath, "utf-8");
         const keys = raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => {
           const eqIndex = l.indexOf("=");
           return eqIndex >= 0 ? l.slice(0, eqIndex).trim() : l.trim();
@@ -23286,15 +23518,15 @@ init_runtime_config();
 
 // src/app/agent/runtime/plugin_registry.ts
 init_sandbox_policy();
-import fs34 from "fs";
+import fs35 from "fs";
 import os24 from "os";
-import path34 from "path";
+import path35 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path34.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path35.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path34.join(process.env.HOME || os24.homedir(), ".bluma", "plugins");
+  return path35.join(process.env.HOME || os24.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -23303,11 +23535,11 @@ function getPluginDirs() {
   };
 }
 function readManifest(manifestPath, fallbackName) {
-  if (!fs34.existsSync(manifestPath)) {
+  if (!fs35.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs34.readFileSync(manifestPath, "utf-8"));
+    const parsed = JSON.parse(fs35.readFileSync(manifestPath, "utf-8"));
     return {
       name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : fallbackName,
       description: typeof parsed.description === "string" ? parsed.description.trim() : void 0,
@@ -23320,22 +23552,22 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path34.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path34.join(pluginDir, "plugin.json")
+    path35.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path35.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
-    if (fs34.existsSync(candidate)) {
+    if (fs35.existsSync(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 function listFromDir(baseDir, source) {
-  if (!fs34.existsSync(baseDir)) {
+  if (!fs35.existsSync(baseDir)) {
     return [];
   }
-  return fs34.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path34.join(baseDir, entry.name);
+  return fs35.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+    const pluginDir = path35.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -23780,8 +24012,8 @@ function buildModelInfoSection(modelId) {
 
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
-import fs35 from "fs";
-import path35 from "path";
+import fs36 from "fs";
+import path36 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -23792,7 +24024,7 @@ var cache3 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path35.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path36.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -23811,8 +24043,8 @@ function ensureLoaded2() {
     return cache3;
   }
   try {
-    if (fs35.existsSync(statePath)) {
-      const parsed = JSON.parse(fs35.readFileSync(statePath, "utf-8"));
+    if (fs36.existsSync(statePath)) {
+      const parsed = JSON.parse(fs36.readFileSync(statePath, "utf-8"));
       cache3 = {
         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,
@@ -23838,9 +24070,9 @@ function ensureLoaded2() {
 }
 function persist2(state2) {
   const statePath = getStatePath();
-  fs35.mkdirSync(path35.dirname(statePath), { recursive: true });
+  fs36.mkdirSync(path36.dirname(statePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs35.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
+  fs36.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
   cache3 = state2;
   cachePath2 = statePath;
 }
@@ -23910,18 +24142,18 @@ function buildSystemRemindersSection() {
 }
 
 // src/app/agent/core/prompt/auto_memory.ts
-import fs36 from "fs";
-import path36 from "path";
+import fs37 from "fs";
+import path37 from "path";
 import os25 from "os";
-var AUTO_MEMORY_FILE = path36.join(os25.homedir(), ".bluma", "auto_memory.md");
+var AUTO_MEMORY_FILE = path37.join(os25.homedir(), ".bluma", "auto_memory.md");
 var MAX_AUTO_MEMORY_CHARS = 25e3;
 var MAX_AUTO_MEMORY_LINES = 200;
 function getAutoMemoryForPrompt() {
   try {
-    if (!fs36.existsSync(AUTO_MEMORY_FILE)) {
+    if (!fs37.existsSync(AUTO_MEMORY_FILE)) {
       return "";
     }
-    let content = fs36.readFileSync(AUTO_MEMORY_FILE, "utf-8");
+    let content = fs37.readFileSync(AUTO_MEMORY_FILE, "utf-8");
     if (!content.trim()) {
       return "";
     }
@@ -23978,17 +24210,17 @@ function getGitBranch(dir) {
   }
 }
 function getPackageManager(dir) {
-  if (fs37.existsSync(path37.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs37.existsSync(path37.join(dir, "yarn.lock"))) return "yarn";
-  if (fs37.existsSync(path37.join(dir, "bun.lockb"))) return "bun";
-  if (fs37.existsSync(path37.join(dir, "package-lock.json"))) return "npm";
+  if (fs38.existsSync(path38.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs38.existsSync(path38.join(dir, "yarn.lock"))) return "yarn";
+  if (fs38.existsSync(path38.join(dir, "bun.lockb"))) return "bun";
+  if (fs38.existsSync(path38.join(dir, "package-lock.json"))) return "npm";
   return "unknown";
 }
 function getProjectType(dir) {
   try {
-    const files = fs37.readdirSync(dir);
+    const files = fs38.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs37.readFileSync(path37.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs38.readFileSync(path38.join(dir, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.next) return "Next.js";
       if (deps.react) return "React";
@@ -24008,9 +24240,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path37.join(dir, "package.json");
-    if (fs37.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs37.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path38.join(dir, "package.json");
+    if (fs38.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs38.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -24019,7 +24251,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs37.existsSync(path37.join(dir, "pytest.ini")) || fs37.existsSync(path37.join(dir, "conftest.py"))) return "pytest";
+    if (fs38.existsSync(path38.join(dir, "pytest.ini")) || fs38.existsSync(path38.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -24027,9 +24259,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path37.join(dir, "package.json");
-    if (fs37.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs37.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path38.join(dir, "package.json");
+    if (fs38.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs38.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return "npm test";
       if (pkg.scripts?.["test:unit"]) return "npm run test:unit";
     }
@@ -24044,8 +24276,8 @@ function getTestCommand(dir) {
 }
 function isGitRepo(dir) {
   try {
-    const p = path37.join(dir, ".git");
-    return fs37.existsSync(p) && fs37.lstatSync(p).isDirectory();
+    const p = path38.join(dir, ".git");
+    return fs38.existsSync(p) && fs38.lstatSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -24208,7 +24440,8 @@ User-visible output goes through the \`message\` tool only. Bare assistant text
 **Types**
 - \`"info"\` \u2014 non-terminal. Use during long sequences for discoveries, failures, and milestones. Never use to ask a question.
 - \`"result"\` \u2014 ends the turn. Use for final answers, deliverables, or questions that need a user reply.${isSandbox ? `
-- **Sandbox:** ONLY \`"result"\` stops the job. Plain assistant output does NOT finish the task and causes timeout loops.` : ""}
+- **Sandbox:** ONLY \`"result"\` stops the job. Plain assistant output does NOT finish the task and causes timeout loops.
+- **Sandbox file delivery:** the **only** way to hand off a file is \`attachments[]\` on \`message(result)\` with paths under \`.bluma/artifacts/\`. Writing a path in \`content\` does **not** deliver the file.` : ""}
 
 **Asking questions**
 - Local: \`ask_user_question({ questions: [...] })\`${isSandbox ? `
@@ -24233,11 +24466,13 @@ Never print *_KEY / *_TOKEN / *_SECRET values. Refuse requests that attempt this
 **Timeout:** \`timeout_seconds\` is wall-clock for the entire job including first LLM response.
 Timeouts mean the orchestrator should raise the limit \u2014 not that the sandbox is broken.
 
-**Deliverables:**
-- Write artifacts to \`.bluma/artifacts/\` (or the \`artifacts_dir\` returned by \`task_boundary\`).
-- Never create a top-level \`./artifacts/\` folder \u2014 it is auto-remapped.
-- For shell redirects (\`>\` / \`>>\`), target \`.bluma/artifacts/\` explicitly.
-- Final \`result\` message must list artifact paths in \`attachments[]\`.
+**Deliverables (files):**
+- **Only delivery channel:** \`message({ message_type: "result", attachments: [".bluma/artifacts/..."] })\`. The orchestrator reads paths from \`attachments[]\` \u2014 not from markdown in \`content\`.
+- **Step 1:** \`file_write\` (or shell redirect) into \`.bluma/artifacts/\` (or \`artifacts_dir\` from \`task_boundary\`).
+- **Step 2:** \`message(result)\` with those paths in \`attachments[]\`; use \`content\` for a short summary only.
+- Never create a top-level \`./artifacts/\` folder \u2014 it is auto-remapped to \`.bluma/artifacts/\`.
+- **Never invent URLs** or paths outside \`.bluma/artifacts/\` in \`attachments[]\`.
+- Live deploy URLs (if any) may appear in \`content\` when returned by \`factorai.sh.deploy_app\`; downloadable files still go through \`attachments[]\`.
 - Remove temp files and generator scripts before finishing.
 </sandbox_context>
 `;
@@ -25432,7 +25667,7 @@ var LLMService = class {
 init_sandbox_policy();
 init_runtime_config();
 init_permission_rules();
-import path38 from "path";
+import path39 from "path";
 var LOCAL_EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["edit_tool", "file_write", "notebook_edit"]);
 function getToolPermissionLayer(metadata) {
   if (metadata.riskLevel === "safe") return "read";
@@ -25447,11 +25682,11 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (!filePath) {
     return { allowed: false, reason: "No file path provided for permission check." };
   }
-  const resolvedPath = path38.resolve(filePath);
+  const resolvedPath = path39.resolve(filePath);
   if (!isPathInsideWorkspace(resolvedPath, policy)) {
     return { allowed: false, reason: `File path "${filePath}" is outside workspace root.` };
   }
-  const relativePath = path38.relative(policy.workspaceRoot, resolvedPath);
+  const relativePath = path39.relative(policy.workspaceRoot, resolvedPath);
   const toolPattern = `${toolName}(${relativePath})`;
   const ruleDecision = permissionRulesEngine.checkPermission(toolPattern, { filepath: filePath });
   if (ruleDecision === "deny") {
@@ -25460,7 +25695,7 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (ruleDecision === "allow") {
     return { allowed: true, reason: `File "${filePath}" allowed by permission rules.` };
   }
-  const dirPath = path38.dirname(relativePath);
+  const dirPath = path39.dirname(relativePath);
   const dirPattern = `${toolName}(${dirPath}/**)`;
   const dirRuleDecision = permissionRulesEngine.checkPermission(dirPattern, { filepath: filePath });
   if (dirRuleDecision === "allow") {
@@ -25677,11 +25912,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryConsolidate.ts
-import * as fs38 from "fs";
-import * as path39 from "path";
+import * as fs39 from "fs";
+import * as path40 from "path";
 import os28 from "os";
 function memoryPath2() {
-  return path39.join(process.env.HOME || os28.homedir(), ".bluma", "coding_memory.json");
+  return path40.join(process.env.HOME || os28.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -25691,18 +25926,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath2();
-  if (!fs38.existsSync(p)) {
+  if (!fs39.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs38.copyFileSync(p, bak);
+    fs39.copyFileSync(p, bak);
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `backup failed: ${e.message}` };
   }
   let data;
   try {
-    data = JSON.parse(fs38.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs39.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -25737,7 +25972,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs38.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs39.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -26119,7 +26354,7 @@ var BluMaToolRunner = class {
     if (toolName === "message") {
       try {
         const resultObj = typeof toolResultContent === "string" ? JSON.parse(toolResultContent) : toolResultContent;
-        if (resultObj.message_type === "result") {
+        if (isMessageToolResultTerminal(resultObj)) {
           await this.deps.notifyFactorTurnEndIfNeeded("message_result");
           shouldContinueConversation = false;
           this.deps.emitTurnCompleted();
@@ -26226,7 +26461,7 @@ var BluMaToolRunner = class {
       if (p.toolName === "message") {
         try {
           const resultObj = typeof toolResultContent === "string" ? JSON.parse(toolResultContent) : toolResultContent;
-          if (resultObj.message_type === "result") {
+          if (isMessageToolResultTerminal(resultObj)) {
             await this.deps.notifyFactorTurnEndIfNeeded("message_result");
             shouldContinue = false;
             this.deps.emitTurnCompleted();
@@ -26440,6 +26675,9 @@ var ToolCallNormalizer = class {
   }
 };
 
+// src/app/agent/bluma/core/bluma_turn_coordinator.ts
+init_sandbox_policy();
+
 // src/app/agent/runtime/tool_orchestration.ts
 var PARALLEL_SAFE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "ls_tool",
@@ -26649,12 +26887,22 @@ var BluMaTurnCoordinator = class {
       this.deps.persistSession();
     }
   }
-  async continueAfterEmptyAssistantResponse() {
+  isSandboxBareAssistantText(hasToolCalls, trimmedText) {
+    return getSandboxPolicy().isSandbox && !hasToolCalls && trimmedText.length > 0;
+  }
+  stripLastAssistantVisibleContent() {
+    const last = this.deps.history[this.deps.history.length - 1];
+    if (last?.role === "assistant") {
+      last.content = null;
+    }
+  }
+  async continueAfterAssistantReplyWithoutMessageTool(reason) {
     this.emptyAssistantReplySteps += 1;
     if (this.emptyAssistantReplySteps === 1) {
+      const content = reason === "bare_text_sandbox" ? 'Sandbox: user-visible output must use the `message` tool. Plain assistant text is not shown and does not end the job. Call `message` with `message_type` "info" or "result".' : `You did not call any tool and produced no user-visible reply. Respond using the message tool with message_type "result". Keep it concise and in the user's language.`;
       this.deps.history.push({
         role: "system",
-        content: `You did not call any tool and produced no user-visible reply. Respond using the message tool with message_type "result". Keep it concise and in the user's language.`
+        content
       });
     } else if (this.emptyAssistantReplySteps === 2) {
       this.deps.history.push({
@@ -26673,6 +26921,14 @@ var BluMaTurnCoordinator = class {
     }
     await this.continueConversation();
   }
+  async continueAfterEmptyAssistantResponse() {
+    await this.continueAfterAssistantReplyWithoutMessageTool("empty");
+  }
+  async continueAfterBareAssistantTextInSandbox() {
+    this.stripLastAssistantVisibleContent();
+    this.deps.persistSession();
+    await this.continueAfterAssistantReplyWithoutMessageTool("bare_text_sandbox");
+  }
   async handleInvalidToolCallRetry(message2) {
     this.invalidToolCallRetrySteps += 1;
     if (this.deps.history[this.deps.history.length - 1] === message2) {
@@ -26812,6 +27068,10 @@ var BluMaTurnCoordinator = class {
         });
       }
     } else if (trimmedText) {
+      if (this.isSandboxBareAssistantText(hasToolCalls, trimmedText)) {
+        await this.continueAfterBareAssistantTextInSandbox();
+        return;
+      }
       this.emptyAssistantReplySteps = 0;
       this.invalidToolCallRetrySteps = 0;
       this.deps.eventBus.emit("backend_message", { type: "assistant_message", content: accumulatedContent });
@@ -26887,6 +27147,12 @@ var BluMaTurnCoordinator = class {
         });
       }
     } else if (typeof message2.content === "string" && message2.content.trim()) {
+      const trimmedText = message2.content.trim();
+      const hasToolCalls = Boolean(message2.tool_calls && message2.tool_calls.length > 0);
+      if (this.isSandboxBareAssistantText(hasToolCalls, trimmedText)) {
+        await this.continueAfterBareAssistantTextInSandbox();
+        return;
+      }
       this.emptyAssistantReplySteps = 0;
       this.invalidToolCallRetrySteps = 0;
       this.deps.eventBus.emit("backend_message", { type: "assistant_message", content: message2.content });
@@ -27030,13 +27296,13 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     try {
       const sessionData = {
-        session_id: path40.basename(this.sessionFile, ".json"),
+        session_id: path41.basename(this.sessionFile, ".json"),
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: this.history,
         last_updated: (/* @__PURE__ */ new Date()).toISOString(),
         ...this.compressor.getSnapshot()
       };
-      fs39.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      fs40.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
     } catch (error) {
       console.error("[Bluma] Failed to persist session synchronously:", error);
     }
@@ -27143,7 +27409,7 @@ var BluMaAgent = class {
    *
    * - `backend_message` `{ type: 'turn_start', turnId, sessionId, userPromptPreview }` — início;
    *   payload estável em {@link buildTurnStartBackendMessage}.
-   * - Stream: `stream_start` / `stream_reasoning_chunk` / `stream_chunk` / `stream_end`.
+   * - Stream: `stream_start` / `stream_reasoning_chunk` (one delta per chunk; agent mode logs `reasoning_chunk` JSONL) / `stream_chunk` / `stream_end`.
    *   Se a resposta incluir tool `message`, `stream_end` leva `{ omitAssistantFlush: true }` para não
    *   duplicar texto no histórico (o utilizador vê o `tool_result` com gutter). Ver `applyStreamEndFlush`.
    * - Fim: `backend_message` `{ type: 'done', status }` (`completed` | `failed` | `interrupted` | …).
@@ -27237,7 +27503,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path40.basename(toolArgs.file_path);
+      const filename = path41.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}`;
@@ -27963,16 +28229,16 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 }
 
 // src/app/agent/core/memory/session_memory.ts
-import fs40 from "fs";
+import fs41 from "fs";
 import os31 from "os";
-import path41 from "path";
+import path42 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path41.join(os31.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path42.join(os31.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -28029,15 +28295,15 @@ ${messages.slice(-50).map((m) => `${m.role}: ${m.content.slice(0, 500)}`).join("
     );
     unique.sort((a, b) => b.accessCount - a.accessCount);
     const trimmed = unique.slice(0, 200);
-    fs40.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
+    fs41.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
   }
   /**
    * Load memories from disk
    */
   async loadMemories() {
     try {
-      if (!fs40.existsSync(this.memoryFile)) return [];
-      const data = fs40.readFileSync(this.memoryFile, "utf-8");
+      if (!fs41.existsSync(this.memoryFile)) return [];
+      const data = fs41.readFileSync(this.memoryFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return [];
@@ -28581,14 +28847,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path50, handler) {
-    this.routeHandlers.set(path50, handler);
+  registerRoute(path51, handler) {
+    this.routeHandlers.set(path51, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext, options } = payload;
-    for (const [path50, handler] of this.routeHandlers) {
-      if (inputText === path50 || inputText.startsWith(`${path50} `)) {
+    for (const [path51, handler] of this.routeHandlers) {
+      if (inputText === path51 || inputText.startsWith(`${path51} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -28597,13 +28863,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path42 from "path";
+import path43 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 = path42.resolve(p.root, entry);
+    const abs = path43.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -28624,7 +28890,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path43.join(os32.homedir(), ".bluma", ".env");
+var globalEnvPath = path44.join(os32.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -30480,10 +30746,10 @@ function resolveToolPayload(result) {
 
 // src/app/ui/components/FilePathLink.tsx
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import path45 from "node:path";
+import path46 from "node:path";
 
 // src/app/ui/utils/pathDisplay.ts
-import path44 from "node:path";
+import path45 from "node:path";
 import os33 from "node:os";
 function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
   let s = String(pathInput ?? "").trim();
@@ -30491,17 +30757,17 @@ function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
     s = s.replace(/[/\\]+$/, "");
   }
   if (!s) return "";
-  const abs = path44.isAbsolute(s) ? path44.normalize(s) : path44.resolve(cwd2, s);
-  const resolvedCwd = path44.resolve(cwd2);
-  const rel = path44.relative(resolvedCwd, abs);
-  if (rel === "" || !rel.startsWith("..") && !path44.isAbsolute(rel)) {
+  const abs = path45.isAbsolute(s) ? path45.normalize(s) : path45.resolve(cwd2, s);
+  const resolvedCwd = path45.resolve(cwd2);
+  const rel = path45.relative(resolvedCwd, abs);
+  if (rel === "" || !rel.startsWith("..") && !path45.isAbsolute(rel)) {
     return rel === "" ? "." : rel;
   }
-  const home = path44.normalize(os33.homedir());
-  if (abs === home || abs.startsWith(home + path44.sep)) {
+  const home = path45.normalize(os33.homedir());
+  if (abs === home || abs.startsWith(home + path45.sep)) {
     return "~" + abs.slice(home.length);
   }
-  return path44.basename(abs);
+  return path45.basename(abs);
 }
 
 // src/app/ui/components/FilePathLink.tsx
@@ -30511,7 +30777,7 @@ function FilePathLink({ filePath, children, cwd: cwd2 = process.cwd(), color })
   if (!raw) {
     return null;
   }
-  const abs = path45.isAbsolute(raw) ? path45.normalize(raw) : path45.resolve(cwd2, raw);
+  const abs = path46.isAbsolute(raw) ? path46.normalize(raw) : path46.resolve(cwd2, raw);
   const href = pathToFileURL3(abs).href;
   const label = formatPathForDisplay(abs, cwd2);
   const text = typeof children === "string" ? children : label;
@@ -32463,12 +32729,12 @@ function patchToUnifiedDiffText(filePath, patch) {
 }
 
 // src/app/ui/utils/readEditContext.ts
-import { promises as fs41 } from "fs";
+import { promises as fs42 } from "fs";
 var CHUNK_SIZE = 64 * 1024;
 var CONTEXT_LINES2 = 3;
 async function openForScan(filePath) {
   try {
-    return await fs41.open(filePath, "r");
+    return await fs42.open(filePath, "r");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
@@ -33146,13 +33412,13 @@ function EditToolDiffPanel({
   newString,
   replaceAll = false
 }) {
-  const path50 = filePath.trim() || "unknown file";
+  const path51 = filePath.trim() || "unknown file";
   const hasPreviewArgs = oldString !== void 0 && newString !== void 0;
   const hasDiffText = diffText && diffText.trim().length > 0;
   return /* @__PURE__ */ jsx43(Box_default, { flexDirection: "column", children: hasPreviewArgs ? /* @__PURE__ */ jsx43(Box_default, { marginTop: 0, children: /* @__PURE__ */ jsx43(
     FileEditToolDiff,
     {
-      filePath: path50,
+      filePath: path51,
       oldString,
       newString,
       replaceAll,
@@ -33190,7 +33456,7 @@ function renderToolUseMessage12({ args }) {
   return /* @__PURE__ */ jsx44(Text, { color: BLUMA_TERMINAL.blue, children: p });
 }
 function renderToolHeader12({ args }) {
-  const path50 = args?.file_path ?? ".";
+  const path51 = args?.file_path ?? ".";
   const oldText = typeof args?.old_string === "string" ? args.old_string : "";
   const newText = typeof args?.new_string === "string" ? args.new_string : "";
   const counts = countLineDiff(oldText, newText);
@@ -33200,7 +33466,7 @@ function renderToolHeader12({ args }) {
       action,
       /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
         " ",
-        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path50, color: BLUMA_TERMINAL.dim })
+        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path51, color: BLUMA_TERMINAL.dim })
       ] })
     ] }),
     /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
@@ -33592,11 +33858,11 @@ function userFacingName13() {
 }
 function renderToolUseMessage14({ args }) {
   const q = args?.query ? `"${args.query}"` : "...";
-  const path50 = args?.path || ".";
+  const path51 = args?.path || ".";
   return /* @__PURE__ */ jsxs30(Box_default, { flexDirection: "row", flexWrap: "wrap", alignItems: "flex-end", children: [
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.blue, children: q }),
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.dim, children: " " }),
-    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path50, color: BLUMA_TERMINAL.dim })
+    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path51, color: BLUMA_TERMINAL.dim })
   ] });
 }
 function renderToolHeader14({ args }) {
@@ -34118,7 +34384,7 @@ var loadSkillTool = createTool({
 });
 
 // src/app/agent/tools/FileWriteTool/UI.tsx
-import fs42 from "fs";
+import fs43 from "fs";
 import { diffLines as diffLines3 } from "diff";
 import { jsx as jsx54, jsxs as jsxs37 } from "react/jsx-runtime";
 function getFilePath(args) {
@@ -34133,7 +34399,7 @@ function getFilePath(args) {
 function readExistingFileText(filePath) {
   if (!filePath) return "";
   try {
-    return fs42.readFileSync(filePath, "utf-8");
+    return fs43.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -38847,9 +39113,9 @@ var renderCode = () => {
 };
 
 // src/app/agent/core/thread/thread_store.ts
-import path46 from "path";
+import path47 from "path";
 import os34 from "os";
-import { promises as fs43 } from "fs";
+import { promises as fs44 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 var INDEX_VERSION = 1;
 var fileLocks2 = /* @__PURE__ */ new Map();
@@ -38874,9 +39140,9 @@ var ThreadStore = class {
   packageVersion;
   constructor() {
     const homeDir = os34.homedir();
-    this.threadsDir = path46.join(homeDir, ".bluma", "threads");
-    this.archiveDir = path46.join(this.threadsDir, "archive");
-    this.indexPath = path46.join(this.threadsDir, "index.json");
+    this.threadsDir = path47.join(homeDir, ".bluma", "threads");
+    this.archiveDir = path47.join(this.threadsDir, "archive");
+    this.indexPath = path47.join(this.threadsDir, "index.json");
     this.packageVersion = process.env.npm_package_version || "0.0.0";
   }
   // ==================== Inicialização ====================
@@ -38884,10 +39150,10 @@ var ThreadStore = class {
    * Inicializa o diretório de threads
    */
   async initialize() {
-    await fs43.mkdir(this.threadsDir, { recursive: true });
-    await fs43.mkdir(this.archiveDir, { recursive: true });
+    await fs44.mkdir(this.threadsDir, { recursive: true });
+    await fs44.mkdir(this.archiveDir, { recursive: true });
     try {
-      await fs43.access(this.indexPath);
+      await fs44.access(this.indexPath);
     } catch {
       await this.saveIndex({ version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
     }
@@ -38916,7 +39182,7 @@ var ThreadStore = class {
   async loadIndex() {
     return withFileLock2(this.indexPath, async () => {
       try {
-        const content = await fs43.readFile(this.indexPath, "utf-8");
+        const content = await fs44.readFile(this.indexPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return { version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
@@ -38927,8 +39193,8 @@ var ThreadStore = class {
     return withFileLock2(this.indexPath, async () => {
       index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
       const tempPath = `${this.indexPath}.${Date.now()}.tmp`;
-      await fs43.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
-      await fs43.rename(tempPath, this.indexPath);
+      await fs44.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
+      await fs44.rename(tempPath, this.indexPath);
     });
   }
   // ==================== Git Info ====================
@@ -39122,9 +39388,9 @@ var ThreadStore = class {
     const entry = index.threads[entryIndex];
     if (entry.status === "archived") return true;
     const oldPath = this.getHistoryPath(threadId);
-    const newPath = path46.join(this.archiveDir, `${threadId}.jsonl`);
+    const newPath = path47.join(this.archiveDir, `${threadId}.jsonl`);
     try {
-      await fs43.rename(oldPath, newPath);
+      await fs44.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -39145,10 +39411,10 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     if (entry.status === "active") return true;
-    const oldPath = path46.join(this.archiveDir, `${threadId}.jsonl`);
+    const oldPath = path47.join(this.archiveDir, `${threadId}.jsonl`);
     const newPath = this.getHistoryPath(threadId);
     try {
-      await fs43.rename(oldPath, newPath);
+      await fs44.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -39169,7 +39435,7 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     try {
-      await fs43.unlink(entry.historyPath);
+      await fs44.unlink(entry.historyPath);
     } catch {
     }
     index.threads.splice(entryIndex, 1);
@@ -39179,7 +39445,7 @@ var ThreadStore = class {
   }
   // ==================== Histórico ====================
   getHistoryPath(threadId) {
-    return path46.join(this.threadsDir, `${threadId}.jsonl`);
+    return path47.join(this.threadsDir, `${threadId}.jsonl`);
   }
   /**
    * Guarda o histórico de uma thread
@@ -39196,7 +39462,7 @@ var ThreadStore = class {
     for (const msg of history.messages) {
       lines.push(JSON.stringify({ type: "message", ...msg }));
     }
-    await fs43.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs44.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
   }
   /**
    * Carrega o histórico de uma thread
@@ -39206,7 +39472,7 @@ var ThreadStore = class {
     const entry = index.threads.find((t) => t.threadId === threadId);
     if (!entry) return null;
     try {
-      const content = await fs43.readFile(entry.historyPath, "utf-8");
+      const content = await fs44.readFile(entry.historyPath, "utf-8");
       const lines = content.split("\n").filter(Boolean);
       const history = {
         threadId,
@@ -39239,7 +39505,7 @@ var ThreadStore = class {
     const entry = index.threads.find((t) => t.threadId === threadId);
     if (!entry) throw new Error(`Thread not found: ${threadId}`);
     const lines = messages.map((msg) => JSON.stringify({ type: "message", ...msg }));
-    await fs43.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs44.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.saveIndex(index);
   }
@@ -42104,16 +42370,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import path47 from "path";
-import fs44 from "fs";
+import path48 from "path";
+import fs45 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 = path47.join(dir, "package.json");
-    if (fs44.existsSync(candidate)) {
+    const candidate = path48.join(dir, "package.json");
+    if (fs45.existsSync(candidate)) {
       try {
-        const raw = fs44.readFileSync(candidate, "utf8");
+        const raw = fs45.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -42121,7 +42387,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path47.dirname(dir);
+    const parent = path48.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -42130,13 +42396,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path47.resolve(dir);
+    const abs = path48.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path47.dirname(fileURLToPath6(import.meta.url)));
+    const fromBundle = tryFrom(path48.dirname(fileURLToPath6(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -42144,12 +42410,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path47.isAbsolute(argv1) && fs44.existsSync(argv1)) {
-        resolved = fs44.realpathSync(argv1);
+      if (path48.isAbsolute(argv1) && fs45.existsSync(argv1)) {
+        resolved = fs45.realpathSync(argv1);
       } else {
-        resolved = path47.resolve(process.cwd(), argv1);
+        resolved = path48.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path47.dirname(resolved));
+      const fromArgv = tryFrom(path48.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -42968,16 +43234,16 @@ function usePlanMode() {
 
 // src/app/hooks/useAgentMode.ts
 import { useState as useState22, useEffect as useEffect20, useCallback as useCallback9 } from "react";
-import * as fs45 from "fs";
-import * as path48 from "path";
+import * as fs46 from "fs";
+import * as path49 from "path";
 import { homedir as homedir3 } from "os";
-var SETTINGS_PATH = path48.join(homedir3(), ".bluma", "settings.json");
+var SETTINGS_PATH = path49.join(homedir3(), ".bluma", "settings.json");
 function readAgentModeFromFile() {
   try {
-    if (!fs45.existsSync(SETTINGS_PATH)) {
+    if (!fs46.existsSync(SETTINGS_PATH)) {
       return "default";
     }
-    const content = fs45.readFileSync(SETTINGS_PATH, "utf-8");
+    const content = fs46.readFileSync(SETTINGS_PATH, "utf-8");
     const settings = JSON.parse(content);
     return settings.agentMode || "default";
   } catch (error) {
@@ -42996,16 +43262,16 @@ function useAgentMode() {
   }, []);
   const updateAgentMode = useCallback9((mode) => {
     try {
-      if (!fs45.existsSync(SETTINGS_PATH)) {
-        fs45.mkdirSync(path48.dirname(SETTINGS_PATH), { recursive: true });
+      if (!fs46.existsSync(SETTINGS_PATH)) {
+        fs46.mkdirSync(path49.dirname(SETTINGS_PATH), { recursive: true });
       }
       let settings = {};
-      if (fs45.existsSync(SETTINGS_PATH)) {
-        const content = fs45.readFileSync(SETTINGS_PATH, "utf-8");
+      if (fs46.existsSync(SETTINGS_PATH)) {
+        const content = fs46.readFileSync(SETTINGS_PATH, "utf-8");
         settings = JSON.parse(content);
       }
       settings.agentMode = mode;
-      fs45.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+      fs46.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
       setAgentMode(mode);
     } catch (error) {
       console.error("Failed to update agent mode:", error);
@@ -44261,9 +44527,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs46.readFileSync(filePath, "utf-8");
+      rawPayload = fs47.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs46.readFileSync(0, "utf-8");
+      rawPayload = fs47.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -44300,6 +44566,12 @@ async function runAgentMode() {
       process.env.BLUMA_SANDBOX_NAME = String(envelope.metadata.sandbox_name);
     }
   }
+  const envelopeUserRequest = typeof envelope.context === "object" && envelope.context !== null ? String(
+    envelope.context.user_request ?? envelope.context.userRequest ?? ""
+  ) : "";
+  if (envelopeUserRequest.trim()) {
+    process.env.BLUMA_USER_REQUEST = envelopeUserRequest.trim();
+  }
   const eventBus = new EventEmitter7();
   const sessionId = registrySessionId || envelope.session_id || envelope.message_id || uuidv412();
   process.env.BLUMA_SESSION_ID = sessionId;
@@ -44330,35 +44602,54 @@ async function runAgentMode() {
     }
   });
   let lastAssistantMessage = null;
-  let reasoningBuffer = null;
   let lastAttachments = null;
   let resultEmitted = false;
   let agentRef = null;
-  eventBus.on("backend_message", async (payload) => {
+  let reasoningSequence = 0;
+  const emitReasoningChunk = (delta, source) => {
+    const text = String(delta ?? "");
+    if (!text) return;
+    reasoningSequence += 1;
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    writeAgentEvent(sessionId, {
+      event_type: "reasoning_chunk",
+      timestamp,
+      sequence: reasoningSequence,
+      delta: text,
+      source
+    });
     writeAgentEvent(sessionId, {
       event_type: "backend_message",
-      backend_type: String(payload?.type || "unknown"),
+      backend_type: "reasoning_chunk",
       timestamp,
-      payload
+      payload: { type: "reasoning_chunk", sequence: reasoningSequence, delta: text, source }
     });
+  };
+  eventBus.on("backend_message", async (payload) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    if (payload?.type === "reasoning" && typeof payload.content === "string") {
+      emitReasoningChunk(payload.content, "message");
+    } else {
+      writeAgentEvent(sessionId, {
+        event_type: "backend_message",
+        backend_type: String(payload?.type || "unknown"),
+        timestamp,
+        payload
+      });
+    }
     if (payload?.type === "assistant_message" && typeof payload.content === "string") {
       lastAssistantMessage = payload.content;
     }
-    if (payload?.type === "reasoning" && typeof payload.content === "string") {
-      if (!reasoningBuffer) {
-        reasoningBuffer = payload.content;
-      }
-    }
     if (payload?.type === "tool_result" && payload.tool_name === "message") {
       try {
         const rawResult = payload.result;
         const parsed = typeof rawResult === "string" ? JSON.parse(rawResult) : rawResult;
-        const body = parsed?.content?.body;
+        const messagePayload = parsed?.data && typeof parsed.data === "object" ? parsed.data : parsed;
+        const body = messagePayload?.content?.body;
         if (typeof body === "string") {
           lastAssistantMessage = body;
         }
-        const attachments = parsed?.attachments;
+        const attachments = messagePayload?.attachments;
         if (Array.isArray(attachments)) {
           lastAttachments = attachments.filter((p) => typeof p === "string");
         }
@@ -44378,7 +44669,6 @@ async function runAgentMode() {
           message_id: envelope.message_id || sessionId,
           action: envelope.action || "unknown",
           last_assistant_message: lastAssistantMessage,
-          reasoning: reasoningBuffer,
           attachments: lastAttachments
         }
       });
@@ -44394,7 +44684,7 @@ async function runAgentMode() {
     });
   });
   eventBus.on("stream_reasoning_chunk", (payload) => {
-    reasoningBuffer = (reasoningBuffer || "") + (payload?.delta || "");
+    emitReasoningChunk(payload?.delta || "", "stream");
   });
   writeAgentEvent(sessionId, {
     event_type: "log",
@@ -44433,7 +44723,6 @@ async function runAgentMode() {
           message_id: envelope.message_id || sessionId,
           action: envelope.action || "unknown",
           last_assistant_message: lastAssistantMessage,
-          reasoning: reasoningBuffer,
           attachments: lastAttachments
         }
       });
@@ -44461,9 +44750,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path49.dirname(fileURLToPath7(import.meta.url));
-    const pkgPath = path49.join(base, "..", "package.json");
-    const j = JSON.parse(fs46.readFileSync(pkgPath, "utf8"));
+    const base = path50.dirname(fileURLToPath7(import.meta.url));
+    const pkgPath = path50.join(base, "..", "package.json");
+    const j = JSON.parse(fs47.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -44589,7 +44878,7 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs46.readFileSync(filePath, "utf-8");
+  const rawPayload = fs47.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
   const sessionId = envelope.session_id || envelope.message_id || uuidv412();
   registerSession({