@nomad-e/bluma-cli 0.19.0 → 0.20.0

package/dist/main.js

@@ -3204,8 +3204,8 @@ __export(exportConversation_exports, {
   formatConversationMarkdown: () => formatConversationMarkdown,
   resolveExportOutputPath: () => resolveExportOutputPath
 });
-import { promises as fs48 } from "fs";
-import path54 from "path";
+import { promises as fs49 } from "fs";
+import path55 from "path";
 function extractTextParts2(content) {
   if (typeof content === "string") {
     const trimmed = content.trim();
@@ -3363,12 +3363,12 @@ function resolveExportOutputPath(sessionId, options) {
   const { outputPath, defaultExportDir } = options ?? {};
   if (outputPath?.trim()) {
     const raw = outputPath.trim();
-    return path54.isAbsolute(raw) ? raw : path54.resolve(process.cwd(), raw);
+    return path55.isAbsolute(raw) ? raw : path55.resolve(process.cwd(), raw);
   }
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const safeId = sessionId.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 48) || "session";
   const baseDir = defaultExportDir ?? getSandboxPolicy().workspaceRoot;
-  return path54.join(baseDir, `bluma-export-${safeId}-${stamp}.md`);
+  return path55.join(baseDir, `bluma-export-${safeId}-${stamp}.md`);
 }
 async function resolveHistory(sessionId, fallbackHistory) {
   const loaded2 = await loadSession(sessionId);
@@ -3390,8 +3390,8 @@ async function exportConversationToFile(options) {
     }
     const markdown = formatConversationMarkdown(sessionId, history);
     const filePath = resolveExportOutputPath(sessionId, { outputPath, defaultExportDir });
-    await fs48.mkdir(path54.dirname(filePath), { recursive: true });
-    await fs48.writeFile(filePath, markdown, "utf-8");
+    await fs49.mkdir(path55.dirname(filePath), { recursive: true });
+    await fs49.writeFile(filePath, markdown, "utf-8");
     return {
       success: true,
       filePath,
@@ -3916,11 +3916,11 @@ var NodeFsOperations = {
       if (fd) fs.closeSync(fd);
     }
   },
-  appendFileSync(path59, data, options) {
-    const _ = slowLogging`fs.appendFileSync(${path59}, ${data.length} chars)`;
+  appendFileSync(path60, data, options) {
+    const _ = slowLogging`fs.appendFileSync(${path60}, ${data.length} chars)`;
     if (options?.mode !== void 0) {
       try {
-        const fd = fs.openSync(path59, "ax", options.mode);
+        const fd = fs.openSync(path60, "ax", options.mode);
         try {
           fs.appendFileSync(fd, data);
         } finally {
@@ -3931,35 +3931,35 @@ var NodeFsOperations = {
         if (getErrnoCode(e) !== "EEXIST") throw e;
       }
     }
-    fs.appendFileSync(path59, data);
+    fs.appendFileSync(path60, data);
   },
   copyFileSync(src, dest) {
     const _ = slowLogging`fs.copyFileSync(${src} → ${dest})`;
     fs.copyFileSync(src, dest);
   },
-  unlinkSync(path59) {
-    const _ = slowLogging`fs.unlinkSync(${path59})`;
-    fs.unlinkSync(path59);
+  unlinkSync(path60) {
+    const _ = slowLogging`fs.unlinkSync(${path60})`;
+    fs.unlinkSync(path60);
   },
   renameSync(oldPath, newPath) {
     const _ = slowLogging`fs.renameSync(${oldPath} → ${newPath})`;
     fs.renameSync(oldPath, newPath);
   },
-  linkSync(target, path59) {
-    const _ = slowLogging`fs.linkSync(${target} → ${path59})`;
-    fs.linkSync(target, path59);
+  linkSync(target, path60) {
+    const _ = slowLogging`fs.linkSync(${target} → ${path60})`;
+    fs.linkSync(target, path60);
   },
-  symlinkSync(target, path59, type) {
-    const _ = slowLogging`fs.symlinkSync(${target} → ${path59})`;
-    fs.symlinkSync(target, path59, type);
+  symlinkSync(target, path60, type) {
+    const _ = slowLogging`fs.symlinkSync(${target} → ${path60})`;
+    fs.symlinkSync(target, path60, type);
   },
-  readlinkSync(path59) {
-    const _ = slowLogging`fs.readlinkSync(${path59})`;
-    return fs.readlinkSync(path59);
+  readlinkSync(path60) {
+    const _ = slowLogging`fs.readlinkSync(${path60})`;
+    return fs.readlinkSync(path60);
   },
-  realpathSync(path59) {
-    const _ = slowLogging`fs.realpathSync(${path59})`;
-    return fs.realpathSync(path59).normalize("NFC");
+  realpathSync(path60) {
+    const _ = slowLogging`fs.realpathSync(${path60})`;
+    return fs.realpathSync(path60).normalize("NFC");
   },
   mkdirSync(dirPath, options) {
     const _ = slowLogging`fs.mkdirSync(${dirPath})`;
@@ -3992,12 +3992,12 @@ var NodeFsOperations = {
     const _ = slowLogging`fs.rmdirSync(${dirPath})`;
     fs.rmdirSync(dirPath);
   },
-  rmSync(path59, options) {
-    const _ = slowLogging`fs.rmSync(${path59})`;
-    fs.rmSync(path59, options);
+  rmSync(path60, options) {
+    const _ = slowLogging`fs.rmSync(${path60})`;
+    fs.rmSync(path60, options);
   },
-  createWriteStream(path59) {
-    return fs.createWriteStream(path59);
+  createWriteStream(path60) {
+    return fs.createWriteStream(path60);
   },
   async readFileBytes(fsPath, maxBytes) {
     if (maxBytes === void 0) {
@@ -4104,12 +4104,12 @@ function shouldLogDebugMessage(message2) {
 var hasFormattedOutput = false;
 var debugWriter = null;
 var pendingWrite = Promise.resolve();
-async function appendAsync(needMkdir, dir, path59, content) {
+async function appendAsync(needMkdir, dir, path60, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {
     });
   }
-  await appendFile(path59, content);
+  await appendFile(path60, content);
   void updateLatestDebugLogSymlink();
 }
 function noop() {
@@ -4119,8 +4119,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path59 = getDebugLogPath();
-        const dir = dirname(path59);
+        const path60 = getDebugLogPath();
+        const dir = dirname(path60);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -4130,11 +4130,11 @@ function getDebugWriter() {
             } catch {
             }
           }
-          getFsImplementation().appendFileSync(path59, content);
+          getFsImplementation().appendFileSync(path60, content);
           void updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path59, content)).catch(noop);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path60, content)).catch(noop);
       },
       flushIntervalMs: 1e3,
       maxBufferSize: 100,
@@ -10321,8 +10321,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 = (path59) => {
-  return path59?.replace(`file://${process.cwd()}/`, "");
+var cleanupPath = (path60) => {
+  return path60?.replace(`file://${process.cwd()}/`, "");
 };
 var stackUtils;
 function getStackUtils() {
@@ -14299,8 +14299,8 @@ var getInstance = (stdout, createInstance) => {
 
 // src/main.ts
 import { EventEmitter as EventEmitter7 } from "events";
-import fs52 from "fs";
-import path58 from "path";
+import fs53 from "fs";
+import path59 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
@@ -14979,7 +14979,7 @@ function cancelSlashSubmenu() {
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path48 from "path";
+import path49 from "path";
 import os30 from "os";
 
 // src/app/agent/tool_invoker.ts
@@ -22028,14 +22028,14 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 
 // src/app/agent/bluma/core/bluma.ts
 init_session_manager();
-import path45 from "path";
-import fs40 from "fs";
+import path46 from "path";
+import fs41 from "fs";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os23 from "os";
-import fs36 from "fs";
-import path39 from "path";
+import fs37 from "fs";
+import path40 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
@@ -23892,12 +23892,12 @@ init_session_memory_paths();
 import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 async function loadSessionMemoryForPrompt(sessionId, cwd2 = process.cwd()) {
   if (!sessionId?.trim()) return "";
-  const path59 = getSessionMemoryPath(sessionId, cwd2);
+  const path60 = getSessionMemoryPath(sessionId, cwd2);
   try {
-    const content = await readFile3(path59, "utf-8");
+    const content = await readFile3(path60, "utf-8");
     if (!content.trim()) return "";
     return `<session_memory>
-Notes for this conversation (${path59}):
+Notes for this conversation (${path60}):
 
 ${content.trim()}
 </session_memory>`;
@@ -23907,11 +23907,11 @@ ${content.trim()}
 }
 async function initSessionMemoryFile(sessionId, cwd2 = process.cwd()) {
   await ensureSessionMemoryDir(sessionId, cwd2);
-  const path59 = getSessionMemoryPath(sessionId, cwd2);
+  const path60 = getSessionMemoryPath(sessionId, cwd2);
   try {
-    await readFile3(path59, "utf-8");
+    await readFile3(path60, "utf-8");
   } catch {
-    await writeFile2(path59, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
+    await writeFile2(path60, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
 `, "utf-8");
   }
 }
@@ -23923,14 +23923,14 @@ var FACTORAI_SH_SECTION = `
 
 **When to load full checklist:** \`load_skill("factorai-sh")\` before any create/deploy/edit/redeploy task.
 
-### Backend URL (already in your environment)
+### Backend URL (see also \`<sandbox_runtime>\` table)
 | Variable | Used by |
 |----------|---------|
 | \`FACTORAI_BASE_URL\` | \`factorai.sh.get_app_status\`, \`factorai.sh.apply_app_changes\`, \`factorai.sh.redeploy_app\` |
 | \`SEVERINO_URL\` | \`factorai.sh.deploy_app\` (ZIP upload to \`/api/v1/deploy\`) |
 | \`FACTORAI_API_KEY\` / \`SEVERINO_API_KEY\` | Optional Bearer on write endpoints |
 
-The orchestrator configures these \u2014 **use the values already set**. Do not invent hosts or assume prod vs dev; tools call whatever base URL the environment provides.
+The orchestrator configures these \u2014 **use the values in \`<sandbox_runtime>\`**, not invented hosts. Autonomous loop: \`tsc --noEmit\` locally \u2192 \`deploy_app\` \u2192 \`get_app_status({ wait: true })\` \u2192 fix on \`failed\` \u2192 only then \`message(result)\`.
 
 ### Source of truth: \`factorai.sh.json\`
 - Written/updated by \`factorai.sh.deploy_app\` and FactorAI tools \u2014 **read with normal file tools**, never a separate manifest tool.
@@ -24013,6 +24013,146 @@ function isFactorAiShPromptEnabled() {
   return isSandbox && Boolean(baseUrl);
 }
 
+// src/app/agent/core/prompt/sandbox_autonomy_prompt.ts
+var SANDBOX_AUTONOMY_SECTION = `
+<sandbox_autonomy>
+## Modo aut\xF3nomo (como Manus / agente de engenharia)
+
+Tu **n\xE3o** est\xE1s num chat interativo com humano ao teclado. Est\xE1s num **worker** com um objetivo, ferramentas, e um prazo. Comportamento esperado:
+
+### 1. Orientar-te (sempre primeiro)
+- L\xEA \`<sandbox_runtime>\` \u2014 session, cwd, URLs, pedido, \`factorai.sh.json\` se existir.
+- Se o pedido envolve Next.js / site / deploy: \`load_skill("factorai-sh")\`.
+- Lista o diret\xF3rio relevante (\`ls_tool\`) antes de assumir estrutura de ficheiros.
+
+### 2. Planear em sil\xEAncio \xFAtil
+- Usa \`todo\` ou \`task_create\` para 3\u20138 passos concretos (n\xE3o gen\xE9ricos).
+- \`message({ message_type: "info" })\` a cada fase importante \u2014 o orquestrador v\xEA progresso.
+
+### 3. Implementar como humano s\xE9nior
+- Edita com \`edit_tool\` / \`file_write\`; l\xEA ficheiros completos antes de patch grande.
+- UI Next: \`@/components/ui/*\` do scaffold; n\xE3o reinventar componentes.
+- Subtarefas paralelas: \`spawn_agent\` + \`wait_agent\` quando fizer sentido.
+
+### 4. Verificar **antes** de deploy (obrigat\xF3rio para apps Next)
+No diret\xF3rio do projeto (ex. \`./my-app\`):
+1. \`npx tsc --noEmit\` \u2014 corrige todos os erros TypeScript.
+2. Opcional: \`npm run lint\` se existir script.
+3. **Evita** \`npm run build\` local **antes do primeiro** \`deploy_app\` (cria \`.next/\` e incha o ZIP). O build de produ\xE7\xE3o corre no FactorAI.sh.
+
+### 5. Deploy e valida\xE7\xE3o remota
+1. \`factorai.sh.deploy_app({ projectDir, name })\` \u2014 primeiro deploy.
+2. \`factorai.sh.get_app_status({ appId, wait: true })\` \u2014 espera \`ready\` ou \`failed\`.
+3. Se \`failed\`: l\xEA \`typescriptErrors\`, \`buildLogTail\`, \`summary\` no resultado; corrige c\xF3digo; \`apply_app_changes\` ou novo deploy; **nunca** digas que est\xE1 online.
+4. S\xF3 depois de \`ready\`: confirma URL (curl ou l\xF3gica) e \`message(result)\` com \`factor-sh-url-app\`.
+
+### 6. Edi\xE7\xF5es em app j\xE1 online (esta sess\xE3o)
+- \`factorai.sh.apply_app_changes\` com ficheiro **completo** em cada \`files[].content\`.
+- Volta a \`get_app_status({ wait: true })\` ap\xF3s rebuild.
+
+### 7. Entregar como produto acabado
+- Ficheiros: \`message(result)\` + \`attachments\` em \`.bluma/artifacts/\`.
+- App live: \`factor-sh-url-app\` com URL absoluta.
+- Resumo em portugu\xEAs claro: o que fizeste, URL, pr\xF3ximos passos se falhou.
+
+### Proibido no sandbox worker
+- Pedir confirma\xE7\xE3o ao utilizador (\`ask_user_question\`) salvo bloqueio real de credencial em falta no env.
+- Inventar URLs, appIds, ou hosts \u2014 usa s\xF3 \`<sandbox_runtime>\` e \`factorai.sh.json\`.
+- \`message(result)\` com sucesso se deploy/build falhou.
+- Ignorar erros de compila\xE7\xE3o (\u201Cvou deploy na mesma\u201D).
+</sandbox_autonomy>
+`;
+
+// src/app/agent/runtime/sandbox_runtime_context.ts
+import fs36 from "fs";
+import path39 from "path";
+function env2(key) {
+  return String(process.env[key] ?? "").trim();
+}
+function listWorkspaceTopLevel(cwd2, max = 24) {
+  try {
+    return fs36.readdirSync(cwd2, { withFileTypes: true }).filter((e) => !e.name.startsWith(".")).slice(0, max).map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+  } catch {
+    return [];
+  }
+}
+function buildSandboxRuntimeContextBlock(cwd2) {
+  const sessionId = env2("BLUMA_SESSION_ID") || "unknown";
+  const sandboxName = env2("BLUMA_SANDBOX_NAME") || "sandbox-api";
+  const fromAgent = env2("BLUMA_FROM_AGENT") || "orchestrator";
+  const action = env2("BLUMA_ACTION") || "unknown";
+  const severinoUrl = env2("SEVERINO_URL");
+  const factoraiUrl = env2("FACTORAI_BASE_URL") || env2("FACTORAI_URL") || severinoUrl;
+  const userRequest = env2("BLUMA_USER_REQUEST");
+  const factoraiEnabled = isFactorAiShPromptEnabled();
+  const top = listWorkspaceTopLevel(cwd2);
+  const lines = [
+    "<sandbox_runtime>",
+    "## Ambiente atual (factos reais \u2014 usa isto para te orientares)",
+    "",
+    "Operas como **agente aut\xF3nomo** (estilo Manus): n\xE3o h\xE1 utilizador no terminal a responder. O orquestrador (Severino / sandbox-api) envia o pedido, observa o teu progresso via `message(info)` e s\xF3 encerra o job com `message(result)`.",
+    "",
+    "| Campo | Valor |",
+    "|-------|-------|",
+    `| sandbox | ${sandboxName} |`,
+    `| session_id | ${sessionId} |`,
+    `| workspace (cwd) | ${cwd2} |`,
+    `| delegado por | ${fromAgent} |`,
+    `| action | ${action} |`,
+    `| node | ${process.version} |`,
+    `| auto_approve_tools | sim (sandbox isolado) |`
+  ];
+  if (severinoUrl) {
+    lines.push(`| SEVERINO_URL (deploy ZIP) | ${severinoUrl} |`);
+  }
+  if (factoraiUrl) {
+    lines.push(`| FACTORAI_BASE_URL (status/apply/redeploy) | ${factoraiUrl} |`);
+  }
+  if (severinoUrl && factoraiUrl && severinoUrl !== factoraiUrl) {
+    lines.push("");
+    lines.push(
+      "\u26A0\uFE0F SEVERINO_URL e FACTORAI_BASE_URL diferem \u2014 confirma qual backend falhou se `get_app_status` der 404 ap\xF3s deploy."
+    );
+  }
+  if (factoraiEnabled) {
+    lines.push("");
+    lines.push("**FactorAI.sh:** ativo nesta sess\xE3o (`factorai.sh.*` tools dispon\xEDveis).");
+  } else {
+    lines.push("");
+    lines.push(
+      "**FactorAI.sh:** n\xE3o configurado (falta `FACTORAI_BASE_URL` ou `BLUMA_SANDBOX`). Hosting Next.js via factorai.sh indispon\xEDvel at\xE9 o orquestrador definir env."
+    );
+  }
+  if (top.length > 0) {
+    lines.push("");
+    lines.push(`**Raiz do workspace:** ${top.join(", ")}`);
+  }
+  const manifest = readFactorAiWorkspaceManifest(cwd2);
+  if (manifest) {
+    const ctx = manifest.appContext;
+    const appId = ctx?.appId;
+    const liveUrl = resolveFactorShAppLiveUrl(cwd2);
+    lines.push("");
+    lines.push("**App FactorAI nesta sess\xE3o (factorai.sh.json):**");
+    if (appId) lines.push(`- appId: ${appId}`);
+    if (liveUrl) lines.push(`- appUrl: ${liveUrl}`);
+    const appDir = typeof manifest.app === "object" && manifest.app && typeof manifest.app.name === "string" ? manifest.app.name : null;
+    if (appDir) {
+      const projectPath = path39.join(cwd2, appDir);
+      if (fs36.existsSync(projectPath)) {
+        lines.push(`- project_dir: ${projectPath}`);
+      }
+    }
+  }
+  if (userRequest) {
+    lines.push("");
+    lines.push("**Pedido deste turno (resumo):**");
+    lines.push(userRequest.length > 2500 ? `${userRequest.slice(0, 2500)}\u2026` : userRequest);
+  }
+  lines.push("</sandbox_runtime>");
+  return lines.join("\n");
+}
+
 // src/app/agent/core/prompt/prompt_builder.ts
 function getNodeVersion() {
   return process.version;
@@ -24044,17 +24184,17 @@ function getGitBranch(dir) {
   }
 }
 function getPackageManager(dir) {
-  if (fs36.existsSync(path39.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs36.existsSync(path39.join(dir, "yarn.lock"))) return "yarn";
-  if (fs36.existsSync(path39.join(dir, "bun.lockb"))) return "bun";
-  if (fs36.existsSync(path39.join(dir, "package-lock.json"))) return "npm";
+  if (fs37.existsSync(path40.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs37.existsSync(path40.join(dir, "yarn.lock"))) return "yarn";
+  if (fs37.existsSync(path40.join(dir, "bun.lockb"))) return "bun";
+  if (fs37.existsSync(path40.join(dir, "package-lock.json"))) return "npm";
   return "unknown";
 }
 function getProjectType(dir) {
   try {
-    const files = fs36.readdirSync(dir);
+    const files = fs37.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs36.readFileSync(path39.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs37.readFileSync(path40.join(dir, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.next) return "Next.js";
       if (deps.react) return "React";
@@ -24074,9 +24214,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path39.join(dir, "package.json");
-    if (fs36.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path40.join(dir, "package.json");
+    if (fs37.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs37.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -24085,7 +24225,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs36.existsSync(path39.join(dir, "pytest.ini")) || fs36.existsSync(path39.join(dir, "conftest.py"))) return "pytest";
+    if (fs37.existsSync(path40.join(dir, "pytest.ini")) || fs37.existsSync(path40.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -24093,9 +24233,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path39.join(dir, "package.json");
-    if (fs36.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path40.join(dir, "package.json");
+    if (fs37.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs37.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return "npm test";
       if (pkg.scripts?.["test:unit"]) return "npm run test:unit";
     }
@@ -24110,8 +24250,8 @@ function getTestCommand(dir) {
 }
 function isGitRepo(dir) {
   try {
-    const p = path39.join(dir, ".git");
-    return fs36.existsSync(p) && fs36.lstatSync(p).isDirectory();
+    const p = path40.join(dir, ".git");
+    return fs37.existsSync(p) && fs37.lstatSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -24322,7 +24462,7 @@ async function getUnifiedSystemPrompt(availableSkills, options) {
   const runtimeConfig = getRuntimeConfig();
   const cwd2 = process.cwd();
   const isSandbox = process.env.BLUMA_SANDBOX === "true";
-  const env2 = {
+  const env3 = {
     os_type: os23.type(),
     os_version: os23.release(),
     architecture: os23.arch(),
@@ -24347,7 +24487,7 @@ async function getUnifiedSystemPrompt(availableSkills, options) {
     session_id: process.env.BLUMA_SESSION_ID || "unknown",
     workspace_root: cwd2
   };
-  const interpolate = (template) => Object.entries(env2).reduce((s, [k, v]) => s.replaceAll(`{${k}}`, v), template);
+  const interpolate = (template) => Object.entries(env3).reduce((s, [k, v]) => s.replaceAll(`{${k}}`, v), template);
   let prompt = interpolate(SYSTEM_PROMPT).replace(
     "<<<BLUMA_WORKSPACE_SNAPSHOT_BODY>>>",
     buildWorkspaceSnapshot(cwd2)
@@ -24366,6 +24506,12 @@ async function getUnifiedSystemPrompt(availableSkills, options) {
     prompt += `
 
 ${SUBJECT_MACHINE_MODEL_XML}`;
+    prompt += `
+
+${buildSandboxRuntimeContextBlock(cwd2)}`;
+    prompt += `
+
+${SANDBOX_AUTONOMY_SECTION}`;
     prompt += interpolate(SANDBOX_SECTION);
     if (isFactorAiShPromptEnabled()) {
       prompt += `
@@ -25545,9 +25691,9 @@ var LLMService = class {
 };
 
 // src/app/agent/utils/user_message_images.ts
-import fs37 from "fs";
+import fs38 from "fs";
 import os25 from "os";
-import path40 from "path";
+import path41 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
 var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
@@ -25563,22 +25709,22 @@ var MIME = {
 function expandUserPath(p) {
   const t = p.trim();
   if (t.startsWith("~")) {
-    return path40.join(os25.homedir(), t.slice(1).replace(/^\//, ""));
+    return path41.join(os25.homedir(), t.slice(1).replace(/^\//, ""));
   }
   return t;
 }
 function isPathAllowed(absResolved, cwd2) {
-  const resolved = path40.normalize(path40.resolve(absResolved));
-  const cwdR = path40.normalize(path40.resolve(cwd2));
-  const homeR = path40.normalize(path40.resolve(os25.homedir()));
-  const tmpR = path40.normalize(path40.resolve(os25.tmpdir()));
-  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path40.sep);
-  const underHome = resolved === homeR || resolved.startsWith(homeR + path40.sep);
-  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path40.sep);
+  const resolved = path41.normalize(path41.resolve(absResolved));
+  const cwdR = path41.normalize(path41.resolve(cwd2));
+  const homeR = path41.normalize(path41.resolve(os25.homedir()));
+  const tmpR = path41.normalize(path41.resolve(os25.tmpdir()));
+  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path41.sep);
+  const underHome = resolved === homeR || resolved.startsWith(homeR + path41.sep);
+  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path41.sep);
   return underCwd || underHome || underTmp;
 }
 function mimeFor(abs) {
-  const ext = path40.extname(abs).toLowerCase();
+  const ext = path41.extname(abs).toLowerCase();
   return MIME[ext] || "application/octet-stream";
 }
 var IMAGE_EXT_SRC = String.raw`(?:png|jpe?g|gif|webp|bmp)`;
@@ -25622,10 +25768,10 @@ function collectImagePathStrings(raw) {
 }
 function resolveImagePath(candidate, cwd2) {
   const expanded = expandUserPath(candidate);
-  const abs = path40.isAbsolute(expanded) ? path40.normalize(expanded) : path40.normalize(path40.resolve(cwd2, expanded));
+  const abs = path41.isAbsolute(expanded) ? path41.normalize(expanded) : path41.normalize(path41.resolve(cwd2, expanded));
   if (!isPathAllowed(abs, cwd2)) return null;
   try {
-    if (!fs37.existsSync(abs) || !fs37.statSync(abs).isFile()) return null;
+    if (!fs38.existsSync(abs) || !fs38.statSync(abs).isFile()) return null;
   } catch {
     return null;
   }
@@ -25645,11 +25791,11 @@ function trySingleLineFileUriOrBareImagePath(line, cwd2) {
   if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
     s = s.slice(1, -1).trim();
   }
-  if (!IMAGE_EXT.test(path40.extname(s))) return null;
+  if (!IMAGE_EXT.test(path41.extname(s))) return null;
   const abs = resolveImagePath(s, cwd2);
   if (!abs) return null;
   try {
-    const st = fs37.statSync(abs);
+    const st = fs38.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -25684,7 +25830,7 @@ function tryPasteChunkAsSingleImagePath(chunk, cwd2) {
     return null;
   }
   try {
-    const st = fs37.statSync(abs);
+    const st = fs38.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -25713,7 +25859,7 @@ function buildUserMessageContent(raw, cwd2) {
     const abs = resolveImagePath(c, cwd2);
     if (!abs) continue;
     try {
-      const st = fs37.statSync(abs);
+      const st = fs38.statSync(abs);
       if (st.size > MAX_IMAGE_BYTES) continue;
     } catch {
       continue;
@@ -25730,7 +25876,7 @@ function buildUserMessageContent(raw, cwd2) {
   }
   const parts = [{ type: "text", text: textPart }];
   for (const abs of resolvedAbs) {
-    const buf = fs37.readFileSync(abs);
+    const buf = fs38.readFileSync(abs);
     const b64 = buf.toString("base64");
     const mime = mimeFor(abs);
     parts.push({
@@ -25748,7 +25894,7 @@ function buildUserMessageContent(raw, cwd2) {
 init_sandbox_policy();
 init_runtime_config();
 init_permission_rules();
-import path41 from "path";
+import path42 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";
@@ -25763,11 +25909,11 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (!filePath) {
     return { allowed: false, reason: "No file path provided for permission check." };
   }
-  const resolvedPath = path41.resolve(filePath);
+  const resolvedPath = path42.resolve(filePath);
   if (!isPathInsideWorkspace(resolvedPath, policy)) {
     return { allowed: false, reason: `File path "${filePath}" is outside workspace root.` };
   }
-  const relativePath = path41.relative(policy.workspaceRoot, resolvedPath);
+  const relativePath = path42.relative(policy.workspaceRoot, resolvedPath);
   const toolPattern = `${toolName}(${relativePath})`;
   const ruleDecision = permissionRulesEngine.checkPermission(toolPattern, { filepath: filePath });
   if (ruleDecision === "deny") {
@@ -25776,7 +25922,7 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (ruleDecision === "allow") {
     return { allowed: true, reason: `File "${filePath}" allowed by permission rules.` };
   }
-  const dirPath = path41.dirname(relativePath);
+  const dirPath = path42.dirname(relativePath);
   const dirPattern = `${toolName}(${dirPath}/**)`;
   const dirRuleDecision = permissionRulesEngine.checkPermission(dirPattern, { filepath: filePath });
   if (dirRuleDecision === "allow") {
@@ -25993,11 +26139,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryConsolidate.ts
-import * as fs38 from "fs";
-import * as path42 from "path";
+import * as fs39 from "fs";
+import * as path43 from "path";
 import os26 from "os";
 function memoryPath2() {
-  return path42.join(process.env.HOME || os26.homedir(), ".bluma", "coding_memory.json");
+  return path43.join(process.env.HOME || os26.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -26007,18 +26153,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}` };
   }
@@ -26053,7 +26199,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}` };
   }
@@ -26559,18 +26705,18 @@ var BluMaToolRunner = class {
 
 // src/app/agent/session_manager/session_archive.ts
 init_bluma_app_dir();
-import path43 from "path";
-import { promises as fs39 } from "fs";
+import path44 from "path";
+import { promises as fs40 } from "fs";
 async function archivePrunedConversationMessages(sessionId, messages) {
   if (!sessionId || messages.length === 0) {
     return null;
   }
   const appDir = getPreferredAppDir();
-  const dir = path43.join(appDir, "sessions", "archive", sessionId);
-  await fs39.mkdir(dir, { recursive: true });
-  const archiveFile = path43.join(dir, `${Date.now()}.jsonl`);
+  const dir = path44.join(appDir, "sessions", "archive", sessionId);
+  await fs40.mkdir(dir, { recursive: true });
+  const archiveFile = path44.join(dir, `${Date.now()}.jsonl`);
   const lines = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  await fs39.appendFile(archiveFile, lines, "utf-8");
+  await fs40.appendFile(archiveFile, lines, "utf-8");
   return archiveFile;
 }
 
@@ -27431,7 +27577,7 @@ Update existing files instead of duplicating.` : "";
 
 // src/app/agent/memory/memory_tool_policy.ts
 init_paths();
-import path44 from "path";
+import path45 from "path";
 var MEMORY_READ_TOOLS = /* @__PURE__ */ new Set([
   "read_file_lines",
   "grep_search",
@@ -27458,7 +27604,7 @@ function isReadOnlyShellCommand(command) {
   return READ_ONLY_SHELL.test(trimmed);
 }
 function createAutoMemToolGate(memoryDir) {
-  const memRoot = memoryDir.endsWith(path44.sep) ? memoryDir : memoryDir + path44.sep;
+  const memRoot = memoryDir.endsWith(path45.sep) ? memoryDir : memoryDir + path45.sep;
   return (toolName, args) => {
     if (MEMORY_READ_TOOLS.has(toolName)) {
       return { allowed: true };
@@ -27471,7 +27617,7 @@ function createAutoMemToolGate(memoryDir) {
     }
     if (MEMORY_WRITE_TOOLS.has(toolName)) {
       const fp = extractFilePath(args);
-      if (fp && isAutoMemPath(path44.resolve(fp))) {
+      if (fp && isAutoMemPath(path45.resolve(fp))) {
         return { allowed: true };
       }
       return { allowed: false, reason: `Writes must stay under ${memRoot}` };
@@ -27480,18 +27626,18 @@ function createAutoMemToolGate(memoryDir) {
   };
 }
 function createSessionMemoryToolGate(sessionMemoryPath) {
-  const resolvedTarget = path44.resolve(sessionMemoryPath);
+  const resolvedTarget = path45.resolve(sessionMemoryPath);
   return (toolName, args) => {
     if (toolName === "read_file_lines") {
       const fp = extractFilePath(args);
-      if (fp && path44.resolve(fp) === resolvedTarget) {
+      if (fp && path45.resolve(fp) === resolvedTarget) {
         return { allowed: true };
       }
       return { allowed: false, reason: "Session memory subagent may only read the session summary file" };
     }
     if (toolName === "edit_tool") {
       const fp = extractFilePath(args);
-      if (fp && path44.resolve(fp) === resolvedTarget) {
+      if (fp && path45.resolve(fp) === resolvedTarget) {
         return { allowed: true };
       }
       return { allowed: false, reason: "Session memory subagent may only edit the session summary file" };
@@ -27518,7 +27664,7 @@ function hasAutoMemWritesSinceHistory(history, sinceIndex) {
         continue;
       }
       const fp = extractFilePath(args);
-      if (fp && isAutoMemPath(path44.resolve(fp))) {
+      if (fp && isAutoMemPath(path45.resolve(fp))) {
         return true;
       }
     }
@@ -27986,13 +28132,13 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     try {
       const sessionData = {
-        session_id: path45.basename(this.sessionFile, ".json"),
+        session_id: path46.basename(this.sessionFile, ".json"),
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: this.history,
         last_updated: (/* @__PURE__ */ new Date()).toISOString(),
         ...this.compressor.getSnapshot()
       };
-      fs40.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      fs41.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
     } catch (error) {
       console.error("[Bluma] Failed to persist session synchronously:", error);
     }
@@ -28198,7 +28344,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path45.basename(toolArgs.file_path);
+      const filename = path46.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}`;
@@ -28933,16 +29079,16 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 }
 
 // src/app/agent/core/memory/session_memory.ts
-import fs41 from "fs";
+import fs42 from "fs";
 import os29 from "os";
-import path46 from "path";
+import path47 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path46.join(os29.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path47.join(os29.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -28999,15 +29145,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);
-    fs41.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
+    fs42.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
   }
   /**
    * Load memories from disk
    */
   async loadMemories() {
     try {
-      if (!fs41.existsSync(this.memoryFile)) return [];
-      const data = fs41.readFileSync(this.memoryFile, "utf-8");
+      if (!fs42.existsSync(this.memoryFile)) return [];
+      const data = fs42.readFileSync(this.memoryFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return [];
@@ -29551,14 +29697,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path59, handler) {
-    this.routeHandlers.set(path59, handler);
+  registerRoute(path60, handler) {
+    this.routeHandlers.set(path60, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext, options } = payload;
-    for (const [path59, handler] of this.routeHandlers) {
-      if (inputText === path59 || inputText.startsWith(`${path59} `)) {
+    for (const [path60, handler] of this.routeHandlers) {
+      if (inputText === path60 || inputText.startsWith(`${path60} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -29567,13 +29713,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path47 from "path";
+import path48 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 = path47.resolve(p.root, entry);
+    const abs = path48.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -29594,7 +29740,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path48.join(os30.homedir(), ".bluma", ".env");
+var globalEnvPath = path49.join(os30.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -31450,10 +31596,10 @@ function resolveToolPayload(result) {
 
 // src/app/ui/components/FilePathLink.tsx
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import path50 from "node:path";
+import path51 from "node:path";
 
 // src/app/ui/utils/pathDisplay.ts
-import path49 from "node:path";
+import path50 from "node:path";
 import os31 from "node:os";
 function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
   let s = String(pathInput ?? "").trim();
@@ -31461,17 +31607,17 @@ function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
     s = s.replace(/[/\\]+$/, "");
   }
   if (!s) return "";
-  const abs = path49.isAbsolute(s) ? path49.normalize(s) : path49.resolve(cwd2, s);
-  const resolvedCwd = path49.resolve(cwd2);
-  const rel = path49.relative(resolvedCwd, abs);
-  if (rel === "" || !rel.startsWith("..") && !path49.isAbsolute(rel)) {
+  const abs = path50.isAbsolute(s) ? path50.normalize(s) : path50.resolve(cwd2, s);
+  const resolvedCwd = path50.resolve(cwd2);
+  const rel = path50.relative(resolvedCwd, abs);
+  if (rel === "" || !rel.startsWith("..") && !path50.isAbsolute(rel)) {
     return rel === "" ? "." : rel;
   }
-  const home = path49.normalize(os31.homedir());
-  if (abs === home || abs.startsWith(home + path49.sep)) {
+  const home = path50.normalize(os31.homedir());
+  if (abs === home || abs.startsWith(home + path50.sep)) {
     return "~" + abs.slice(home.length);
   }
-  return path49.basename(abs);
+  return path50.basename(abs);
 }
 
 // src/app/ui/components/FilePathLink.tsx
@@ -31481,7 +31627,7 @@ function FilePathLink({ filePath, children, cwd: cwd2 = process.cwd(), color })
   if (!raw) {
     return null;
   }
-  const abs = path50.isAbsolute(raw) ? path50.normalize(raw) : path50.resolve(cwd2, raw);
+  const abs = path51.isAbsolute(raw) ? path51.normalize(raw) : path51.resolve(cwd2, raw);
   const href = pathToFileURL3(abs).href;
   const label = formatPathForDisplay(abs, cwd2);
   const text = typeof children === "string" ? children : label;
@@ -32102,16 +32248,16 @@ function supportsHyperlinks(options) {
   if (stdoutSupported) {
     return true;
   }
-  const env2 = options?.env ?? process.env;
-  const termProgram = env2["TERM_PROGRAM"];
+  const env3 = options?.env ?? process.env;
+  const termProgram = env3["TERM_PROGRAM"];
   if (termProgram && ADDITIONAL_HYPERLINK_TERMINALS.includes(termProgram)) {
     return true;
   }
-  const lcTerminal = env2["LC_TERMINAL"];
+  const lcTerminal = env3["LC_TERMINAL"];
   if (lcTerminal && ADDITIONAL_HYPERLINK_TERMINALS.includes(lcTerminal)) {
     return true;
   }
-  const term = env2["TERM"];
+  const term = env3["TERM"];
   if (term?.includes("kitty")) {
     return true;
   }
@@ -33433,12 +33579,12 @@ function patchToUnifiedDiffText(filePath, patch) {
 }
 
 // src/app/ui/utils/readEditContext.ts
-import { promises as fs42 } from "fs";
+import { promises as fs43 } from "fs";
 var CHUNK_SIZE = 64 * 1024;
 var CONTEXT_LINES2 = 3;
 async function openForScan(filePath) {
   try {
-    return await fs42.open(filePath, "r");
+    return await fs43.open(filePath, "r");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
@@ -34116,13 +34262,13 @@ function EditToolDiffPanel({
   newString,
   replaceAll = false
 }) {
-  const path59 = filePath.trim() || "unknown file";
+  const path60 = 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: path59,
+      filePath: path60,
       oldString,
       newString,
       replaceAll,
@@ -34160,7 +34306,7 @@ function renderToolUseMessage12({ args }) {
   return /* @__PURE__ */ jsx44(Text, { color: BLUMA_TERMINAL.blue, children: p });
 }
 function renderToolHeader12({ args }) {
-  const path59 = args?.file_path ?? ".";
+  const path60 = 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);
@@ -34170,7 +34316,7 @@ function renderToolHeader12({ args }) {
       action,
       /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
         " ",
-        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path59, color: BLUMA_TERMINAL.dim })
+        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path60, color: BLUMA_TERMINAL.dim })
       ] })
     ] }),
     /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
@@ -34562,11 +34708,11 @@ function userFacingName13() {
 }
 function renderToolUseMessage14({ args }) {
   const q = args?.query ? `"${args.query}"` : "...";
-  const path59 = args?.path || ".";
+  const path60 = 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: path59, color: BLUMA_TERMINAL.dim })
+    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path60, color: BLUMA_TERMINAL.dim })
   ] });
 }
 function renderToolHeader14({ args }) {
@@ -35088,7 +35234,7 @@ var loadSkillTool = createTool({
 });
 
 // src/app/agent/tools/FileWriteTool/UI.tsx
-import fs43 from "fs";
+import fs44 from "fs";
 import { diffLines as diffLines3 } from "diff";
 import { jsx as jsx54, jsxs as jsxs37 } from "react/jsx-runtime";
 function getFilePath(args) {
@@ -35103,7 +35249,7 @@ function getFilePath(args) {
 function readExistingFileText(filePath) {
   if (!filePath) return "";
   try {
-    return fs43.readFileSync(filePath, "utf-8");
+    return fs44.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -38045,8 +38191,8 @@ import {
 
 // src/app/ui/hooks/useAtCompletion.ts
 import { useEffect as useEffect11, useRef as useRef4, useState as useState13 } from "react";
-import fs44 from "fs";
-import path51 from "path";
+import fs45 from "fs";
+import path52 from "path";
 var MAX_RESULTS3 = 50;
 var DEFAULT_RECURSIVE_DEPTH = 2;
 function listPathSuggestions(baseDir, pattern) {
@@ -38054,7 +38200,7 @@ function listPathSuggestions(baseDir, pattern) {
   const patternEndsWithSlash = raw.endsWith("/");
   const relDir = raw.replace(/^\/+|\/+$/g, "");
   const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
-  const listDir = path51.resolve(baseDir, relDir || ".");
+  const listDir = path52.resolve(baseDir, relDir || ".");
   const results = [];
   const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
   const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
@@ -38071,7 +38217,7 @@ function listPathSuggestions(baseDir, pattern) {
   }
   function pushEntry(entryPath, label, isDir) {
     if (results.length >= MAX_RESULTS3) return;
-    const clean = label.split(path51.sep).join("/").replace(/[]+/g, "");
+    const clean = label.split(path52.sep).join("/").replace(/[]+/g, "");
     results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
   }
   try {
@@ -38080,11 +38226,11 @@ function listPathSuggestions(baseDir, pattern) {
       while (queue.length && results.length < MAX_RESULTS3) {
         const node = queue.shift();
         try {
-          const entries = fs44.readdirSync(node.dir, { withFileTypes: true });
+          const entries = fs45.readdirSync(node.dir, { withFileTypes: true });
           for (const entry of entries) {
             if (isIgnoredName(entry.name)) continue;
-            const entryAbs = path51.join(node.dir, entry.name);
-            const entryRel = node.rel ? path51.posix.join(node.rel, entry.name) : entry.name;
+            const entryAbs = path52.join(node.dir, entry.name);
+            const entryRel = node.rel ? path52.posix.join(node.rel, entry.name) : entry.name;
             if (entryRel.split("/").includes("node_modules")) continue;
             if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
             pushEntry(entryAbs, entryRel, entry.isDirectory());
@@ -38097,13 +38243,13 @@ function listPathSuggestions(baseDir, pattern) {
         }
       }
     } else {
-      const entries = fs44.readdirSync(listDir, { withFileTypes: true });
+      const entries = fs45.readdirSync(listDir, { withFileTypes: true });
       for (const entry of entries) {
         if (filterPrefix && !entry.name.startsWith(filterPrefix)) continue;
         if (isIgnoredName(entry.name)) continue;
         if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
-        const entryAbs = path51.join(listDir, entry.name);
-        const label = relDir ? path51.posix.join(relDir, entry.name) : entry.name;
+        const entryAbs = path52.join(listDir, entry.name);
+        const label = relDir ? path52.posix.join(relDir, entry.name) : entry.name;
         pushEntry(entryAbs, label, entry.isDirectory());
         if (results.length >= MAX_RESULTS3) break;
       }
@@ -38304,9 +38450,9 @@ var SlashSubmenuInlineComponent = ({ menu }) => {
 var SlashSubmenuInline = memo15(SlashSubmenuInlineComponent);
 
 // src/app/ui/utils/clipboardImage.ts
-import fs45 from "fs";
+import fs46 from "fs";
 import os32 from "os";
-import path52 from "path";
+import path53 from "path";
 import { spawn as spawn5, execFile as execFileCb, execSync as execSync4 } from "child_process";
 import { promisify as promisify2 } from "util";
 
@@ -38435,8 +38581,8 @@ function commandOnPath(cmd) {
 function unixClipboardHelperDirs() {
   const h = os32.homedir();
   return [
-    path52.join(h, ".local", "bin"),
-    path52.join(h, "bin"),
+    path53.join(h, ".local", "bin"),
+    path53.join(h, "bin"),
     "/usr/bin",
     "/usr/local/bin",
     "/bin",
@@ -38454,16 +38600,16 @@ function resolveHelperBinary(cmd) {
     return cmd;
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path52.join(dir, cmd);
+    const full = path53.join(dir, cmd);
     try {
-      fs45.accessSync(full, fs45.constants.X_OK);
+      fs46.accessSync(full, fs46.constants.X_OK);
       return full;
     } catch {
     }
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path52.join(dir, cmd);
-    if (fs45.existsSync(full)) {
+    const full = path53.join(dir, cmd);
+    if (fs46.existsSync(full)) {
       return full;
     }
   }
@@ -38504,17 +38650,17 @@ function writeBufferIfImage(baseDir, buf) {
   if (!ext) {
     return null;
   }
-  const out = path52.join(
+  const out = path53.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
-  fs45.writeFileSync(out, buf);
+  fs46.writeFileSync(out, buf);
   return out;
 }
 function unlinkQuiet(p) {
   try {
-    if (fs45.existsSync(p)) {
-      fs45.unlinkSync(p);
+    if (fs46.existsSync(p)) {
+      fs46.unlinkSync(p);
     }
   } catch {
   }
@@ -38531,25 +38677,25 @@ async function tryDarwinClipboardy(baseDir) {
       return null;
     }
     for (const src of tmpPaths) {
-      if (!src || !fs45.existsSync(src)) {
+      if (!src || !fs46.existsSync(src)) {
         continue;
       }
       let st;
       try {
-        st = fs45.statSync(src);
+        st = fs46.statSync(src);
       } catch {
         continue;
       }
       if (st.size < 80 || st.size > CLIPBOARD_MAX_BYTES) {
         continue;
       }
-      const ext = path52.extname(src).toLowerCase();
+      const ext = path53.extname(src).toLowerCase();
       const safeExt = ext && /^\.(png|jpe?g|gif|webp)$/i.test(ext) ? ext : ".png";
-      const out = path52.join(
+      const out = path53.join(
         baseDir,
         `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${safeExt}`
       );
-      fs45.copyFileSync(src, out);
+      fs46.copyFileSync(src, out);
       for (const p of tmpPaths) {
         unlinkQuiet(p);
       }
@@ -38563,14 +38709,14 @@ async function tryDarwinClipboardy(baseDir) {
   return null;
 }
 async function tryWindowsPowerShell(outFile) {
-  const ps = process.env.SystemRoot != null ? path52.join(
+  const ps = process.env.SystemRoot != null ? path53.join(
     process.env.SystemRoot,
     "System32",
     "WindowsPowerShell",
     "v1.0",
     "powershell.exe"
   ) : "powershell.exe";
-  if (!fs45.existsSync(ps)) {
+  if (!fs46.existsSync(ps)) {
     return false;
   }
   const script = "$ErrorActionPreference='Stop';Add-Type -AssemblyName System.Windows.Forms;Add-Type -AssemblyName System.Drawing;$img=[System.Windows.Forms.Clipboard]::GetImage();if($null -eq $img){exit 2};$img.Save($env:BLUMA_CLIP_OUT,[System.Drawing.Imaging.ImageFormat]::Png);exit 0";
@@ -38592,7 +38738,7 @@ async function tryWindowsPowerShell(outFile) {
     return false;
   }
   try {
-    const st = fs45.statSync(outFile);
+    const st = fs46.statSync(outFile);
     return st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES;
   } catch {
     return false;
@@ -38664,8 +38810,8 @@ function parseClipboardTextAsImagePath(raw) {
     s = s.slice(1, -1);
   }
   s = s.trim();
-  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path52.extname(s))) return null;
-  const abs = path52.isAbsolute(s) ? path52.normalize(s) : path52.resolve(process.cwd(), s);
+  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path53.extname(s))) return null;
+  const abs = path53.isAbsolute(s) ? path53.normalize(s) : path53.resolve(process.cwd(), s);
   return abs;
 }
 async function tryClipboardTextAsImageFile(baseDir) {
@@ -38679,19 +38825,19 @@ async function tryClipboardTextAsImageFile(baseDir) {
   const abs = parseClipboardTextAsImagePath(t);
   if (!abs) return null;
   try {
-    if (!fs45.existsSync(abs)) return null;
-    const st = fs45.statSync(abs);
+    if (!fs46.existsSync(abs)) return null;
+    const st = fs46.statSync(abs);
     if (!st.isFile() || st.size > CLIPBOARD_MAX_BYTES || st.size < 20) return null;
   } catch {
     return null;
   }
-  const ext = path52.extname(abs).toLowerCase();
-  const out = path52.join(
+  const ext = path53.extname(abs).toLowerCase();
+  const out = path53.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
   try {
-    fs45.copyFileSync(abs, out);
+    fs46.copyFileSync(abs, out);
     return out;
   } catch {
     return null;
@@ -38701,7 +38847,7 @@ async function tryLinuxShellPipelineSave(baseDir) {
   if (process.platform !== "linux" && process.platform !== "freebsd") {
     return null;
   }
-  const outPath = path52.join(
+  const outPath = path53.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`
   );
@@ -38723,11 +38869,11 @@ printf '%s' "$OUT"
       maxBuffer: 4096
     });
     const written = String(stdout ?? "").trim();
-    if (written !== outPath || !fs45.existsSync(outPath)) {
+    if (written !== outPath || !fs46.existsSync(outPath)) {
       unlinkQuiet(outPath);
       return null;
     }
-    const buf = fs45.readFileSync(outPath);
+    const buf = fs46.readFileSync(outPath);
     unlinkQuiet(outPath);
     return writeBufferIfImage(baseDir, buf);
   } catch {
@@ -38748,8 +38894,8 @@ async function tryNativeClipboardImage() {
   }
   try {
     const result = readClipboardImageNative();
-    if (fs45.existsSync(result.path)) {
-      const st = fs45.statSync(result.path);
+    if (fs46.existsSync(result.path)) {
+      const st = fs46.statSync(result.path);
       if (st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES) {
         return result.path;
       }
@@ -38759,8 +38905,8 @@ async function tryNativeClipboardImage() {
   return null;
 }
 async function readClipboardImageToTempFile() {
-  const baseDir = path52.join(os32.homedir(), ".cache", "bluma", "clipboard");
-  fs45.mkdirSync(baseDir, { recursive: true });
+  const baseDir = path53.join(os32.homedir(), ".cache", "bluma", "clipboard");
+  fs46.mkdirSync(baseDir, { recursive: true });
   const nativeResult = await tryNativeClipboardImage();
   if (nativeResult) {
     return nativeResult;
@@ -38778,7 +38924,7 @@ async function readClipboardImageToTempFile() {
     }
   }
   if (process.platform === "win32") {
-    const outFile = path52.join(
+    const outFile = path53.join(
       baseDir,
       `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`
     );
@@ -38819,7 +38965,7 @@ function expandLargePastePlaceholder(value, pending) {
 }
 
 // src/app/ui/components/InputPrompt.tsx
-import fs46 from "fs";
+import fs47 from "fs";
 import { Fragment as Fragment7, jsx as jsx79, jsxs as jsxs62 } from "react/jsx-runtime";
 var persistedInputState = { text: "", cursorPosition: 0 };
 var StaticCursor = () => /* @__PURE__ */ jsx79(Box_default, { flexDirection: "row", flexWrap: "nowrap", children: /* @__PURE__ */ jsx79(Text, { bold: true, color: BLUMA_TERMINAL.m3OnSurface, children: "\u2588 " }) });
@@ -38986,7 +39132,7 @@ var InputPrompt = memo16(({
           return;
         }
         if (routeText.startsWith("/")) {
-          const isFilePath = map.size > 0 && fs46.existsSync(routeText.split(/\s+/)[0]);
+          const isFilePath = map.size > 0 && fs47.existsSync(routeText.split(/\s+/)[0]);
           if (isFilePath) {
             uiEventBus.emit("user_overlay", {
               kind: "message",
@@ -41154,8 +41300,8 @@ var renderSettingsEditUsage = () => {
 
 // src/app/agent/core/thread/thread_store.ts
 init_bluma_app_dir();
-import path53 from "path";
-import { promises as fs47 } from "fs";
+import path54 from "path";
+import { promises as fs48 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 var INDEX_VERSION = 1;
 var fileLocks2 = /* @__PURE__ */ new Map();
@@ -41180,9 +41326,9 @@ var ThreadStore = class {
   packageVersion;
   constructor() {
     const appDir = getPreferredAppDir();
-    this.threadsDir = path53.join(appDir, "threads");
-    this.archiveDir = path53.join(this.threadsDir, "archive");
-    this.indexPath = path53.join(this.threadsDir, "index.json");
+    this.threadsDir = path54.join(appDir, "threads");
+    this.archiveDir = path54.join(this.threadsDir, "archive");
+    this.indexPath = path54.join(this.threadsDir, "index.json");
     this.packageVersion = process.env.npm_package_version || "0.0.0";
   }
   // ==================== Inicialização ====================
@@ -41190,10 +41336,10 @@ var ThreadStore = class {
    * Inicializa o diretório de threads
    */
   async initialize() {
-    await fs47.mkdir(this.threadsDir, { recursive: true });
-    await fs47.mkdir(this.archiveDir, { recursive: true });
+    await fs48.mkdir(this.threadsDir, { recursive: true });
+    await fs48.mkdir(this.archiveDir, { recursive: true });
     try {
-      await fs47.access(this.indexPath);
+      await fs48.access(this.indexPath);
     } catch {
       await this.saveIndex({ version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
     }
@@ -41222,7 +41368,7 @@ var ThreadStore = class {
   async loadIndex() {
     return withFileLock2(this.indexPath, async () => {
       try {
-        const content = await fs47.readFile(this.indexPath, "utf-8");
+        const content = await fs48.readFile(this.indexPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return { version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
@@ -41233,8 +41379,8 @@ var ThreadStore = class {
     return withFileLock2(this.indexPath, async () => {
       index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
       const tempPath = `${this.indexPath}.${Date.now()}.tmp`;
-      await fs47.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
-      await fs47.rename(tempPath, this.indexPath);
+      await fs48.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
+      await fs48.rename(tempPath, this.indexPath);
     });
   }
   // ==================== Git Info ====================
@@ -41304,7 +41450,7 @@ var ThreadStore = class {
       messages: params.initialMessages || []
     };
     const historyPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path53.dirname(historyPath), { recursive: true });
+    await fs48.mkdir(path54.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -41359,7 +41505,7 @@ var ThreadStore = class {
       compressedSliceCount: source.history.compressedSliceCount
     };
     const historyPath = this.buildDatedThreadHistoryPath(newThreadId);
-    await fs47.mkdir(path53.dirname(historyPath), { recursive: true });
+    await fs48.mkdir(path54.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -41432,9 +41578,9 @@ var ThreadStore = class {
     const entry = index.threads[entryIndex];
     if (entry.status === "archived") return true;
     const oldPath = entry.historyPath || this.getLegacyHistoryPath(threadId);
-    const newPath = path53.join(this.archiveDir, `${threadId}.jsonl`);
+    const newPath = path54.join(this.archiveDir, `${threadId}.jsonl`);
     try {
-      await fs47.rename(oldPath, newPath);
+      await fs48.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -41455,11 +41601,11 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     if (entry.status === "active") return true;
-    const oldPath = path53.join(this.archiveDir, `${threadId}.jsonl`);
+    const oldPath = path54.join(this.archiveDir, `${threadId}.jsonl`);
     const newPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path53.dirname(newPath), { recursive: true });
+    await fs48.mkdir(path54.dirname(newPath), { recursive: true });
     try {
-      await fs47.rename(oldPath, newPath);
+      await fs48.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -41480,7 +41626,7 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     try {
-      await fs47.unlink(entry.historyPath);
+      await fs48.unlink(entry.historyPath);
     } catch {
     }
     index.threads.splice(entryIndex, 1);
@@ -41490,28 +41636,28 @@ var ThreadStore = class {
   }
   // ==================== Histórico ====================
   getLegacyHistoryPath(threadId) {
-    return path53.join(this.threadsDir, `${threadId}.jsonl`);
+    return path54.join(this.threadsDir, `${threadId}.jsonl`);
   }
   /** ~/.bluma/threads/YYYY/MM/DD/<threadId>.jsonl (data local de criação). */
   buildDatedThreadHistoryPath(threadId, at = /* @__PURE__ */ new Date()) {
     const y = String(at.getFullYear());
     const mo = String(at.getMonth() + 1).padStart(2, "0");
     const d = String(at.getDate()).padStart(2, "0");
-    return path53.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
+    return path54.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
   }
   async resolveHistoryPath(threadId) {
     const index = await this.loadIndex();
     const entry = index.threads.find((t) => t.threadId === threadId);
     if (entry?.historyPath) {
       try {
-        await fs47.access(entry.historyPath);
+        await fs48.access(entry.historyPath);
         return entry.historyPath;
       } catch {
       }
     }
     const legacy = this.getLegacyHistoryPath(threadId);
     try {
-      await fs47.access(legacy);
+      await fs48.access(legacy);
       return legacy;
     } catch {
       return entry?.historyPath ?? legacy;
@@ -41528,9 +41674,9 @@ var ThreadStore = class {
     for (const msg of history.messages) {
       lines.push(JSON.stringify({ type: "message", ...msg }));
     }
-    await fs47.mkdir(path53.dirname(historyPath), { recursive: true }).catch(() => {
+    await fs48.mkdir(path54.dirname(historyPath), { recursive: true }).catch(() => {
     });
-    await fs47.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs48.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
   }
   /**
    * Guarda o histórico de uma thread
@@ -41552,7 +41698,7 @@ var ThreadStore = class {
     ].filter((p, i, arr) => Boolean(p) && arr.indexOf(p) === i);
     for (const historyPath of pathsToTry) {
       try {
-        const content = await fs47.readFile(historyPath, "utf-8");
+        const content = await fs48.readFile(historyPath, "utf-8");
         const lines = content.split("\n").filter(Boolean);
         const history = {
           threadId,
@@ -41587,7 +41733,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 fs47.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs48.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.saveIndex(index);
   }
@@ -44024,16 +44170,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath7 } from "url";
-import path55 from "path";
-import fs49 from "fs";
+import path56 from "path";
+import fs50 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 = path55.join(dir, "package.json");
-    if (fs49.existsSync(candidate)) {
+    const candidate = path56.join(dir, "package.json");
+    if (fs50.existsSync(candidate)) {
       try {
-        const raw = fs49.readFileSync(candidate, "utf8");
+        const raw = fs50.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -44041,7 +44187,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path55.dirname(dir);
+    const parent = path56.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -44050,13 +44196,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path55.resolve(dir);
+    const abs = path56.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path55.dirname(fileURLToPath7(import.meta.url)));
+    const fromBundle = tryFrom(path56.dirname(fileURLToPath7(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -44064,12 +44210,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path55.isAbsolute(argv1) && fs49.existsSync(argv1)) {
-        resolved = fs49.realpathSync(argv1);
+      if (path56.isAbsolute(argv1) && fs50.existsSync(argv1)) {
+        resolved = fs50.realpathSync(argv1);
       } else {
-        resolved = path55.resolve(process.cwd(), argv1);
+        resolved = path56.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path55.dirname(resolved));
+      const fromArgv = tryFrom(path56.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -44888,16 +45034,16 @@ function usePlanMode() {
 
 // src/app/hooks/useAgentMode.ts
 import { useState as useState22, useEffect as useEffect21, useCallback as useCallback9 } from "react";
-import * as fs50 from "fs";
-import * as path56 from "path";
+import * as fs51 from "fs";
+import * as path57 from "path";
 import { homedir as homedir4 } from "os";
-var SETTINGS_PATH = path56.join(homedir4(), ".bluma", "settings.json");
+var SETTINGS_PATH = path57.join(homedir4(), ".bluma", "settings.json");
 function readAgentModeFromFile() {
   try {
-    if (!fs50.existsSync(SETTINGS_PATH)) {
+    if (!fs51.existsSync(SETTINGS_PATH)) {
       return "default";
     }
-    const content = fs50.readFileSync(SETTINGS_PATH, "utf-8");
+    const content = fs51.readFileSync(SETTINGS_PATH, "utf-8");
     const settings = JSON.parse(content);
     return settings.agentMode || "default";
   } catch (error) {
@@ -44916,16 +45062,16 @@ function useAgentMode() {
   }, []);
   const updateAgentMode = useCallback9((mode) => {
     try {
-      if (!fs50.existsSync(SETTINGS_PATH)) {
-        fs50.mkdirSync(path56.dirname(SETTINGS_PATH), { recursive: true });
+      if (!fs51.existsSync(SETTINGS_PATH)) {
+        fs51.mkdirSync(path57.dirname(SETTINGS_PATH), { recursive: true });
       }
       let settings = {};
-      if (fs50.existsSync(SETTINGS_PATH)) {
-        const content = fs50.readFileSync(SETTINGS_PATH, "utf-8");
+      if (fs51.existsSync(SETTINGS_PATH)) {
+        const content = fs51.readFileSync(SETTINGS_PATH, "utf-8");
         settings = JSON.parse(content);
       }
       settings.agentMode = mode;
-      fs50.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+      fs51.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
       setAgentMode(mode);
     } catch (error) {
       console.error("Failed to update agent mode:", error);
@@ -46189,10 +46335,10 @@ import { memo as memo26, useCallback as useCallback11, useEffect as useEffect23,
 
 // src/app/agent/session_manager/session_resume_browser.ts
 init_bluma_app_dir();
-import path57 from "path";
-import { promises as fs51 } from "fs";
+import path58 from "path";
+import { promises as fs52 } from "fs";
 function getSessionsRoot() {
-  return path57.join(getPreferredAppDir(), "sessions");
+  return path58.join(getPreferredAppDir(), "sessions");
 }
 function normalizeSessionsCwd(cwd2) {
   return cwd2.replace(/\\/g, "/").split("/").filter((p) => p && p !== "." && p !== "..").join("/");
@@ -46213,9 +46359,9 @@ async function sessionEntryFromFile(absPath, sessionId) {
   let preview = "(no messages)";
   let lastActivityMs = Date.now();
   try {
-    const st = await fs51.stat(absPath);
+    const st = await fs52.stat(absPath);
     lastActivityMs = st.mtimeMs;
-    const raw = await fs51.readFile(absPath, "utf-8");
+    const raw = await fs52.readFile(absPath, "utf-8");
     const data = JSON.parse(raw);
     preview = previewFromHistory(data.conversation_history);
     const iso = data.last_updated || data.created_at;
@@ -46243,15 +46389,15 @@ function compareDirNames(a, b) {
 async function listSessionBrowserEntries(cwdRel) {
   const cwd2 = normalizeSessionsCwd(cwdRel);
   const root = getSessionsRoot();
-  const absDir = cwd2 ? path57.join(root, ...cwd2.split("/")) : root;
+  const absDir = cwd2 ? path58.join(root, ...cwd2.split("/")) : root;
   const out = [];
   if (cwd2) {
     out.push({ kind: "up", label: ".." });
   }
   let dirents;
   try {
-    await fs51.mkdir(absDir, { recursive: true });
-    dirents = await fs51.readdir(absDir, { withFileTypes: true });
+    await fs52.mkdir(absDir, { recursive: true });
+    dirents = await fs52.readdir(absDir, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -46260,7 +46406,7 @@ async function listSessionBrowserEntries(cwdRel) {
   for (const e of dirents) {
     const name = String(e.name);
     if (name.startsWith(".")) continue;
-    const full = path57.join(absDir, name);
+    const full = path58.join(absDir, name);
     if (e.isDirectory()) {
       dirNames.push(name);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -46270,7 +46416,7 @@ async function listSessionBrowserEntries(cwdRel) {
   dirNames.sort(compareDirNames);
   const sessions = [];
   for (const { name, full } of sessionFiles) {
-    const sessionId = path57.basename(name, ".json");
+    const sessionId = path58.basename(name, ".json");
     sessions.push(await sessionEntryFromFile(full, sessionId));
   }
   sessions.sort((a, b) => {
@@ -46635,9 +46781,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs52.readFileSync(filePath, "utf-8");
+      rawPayload = fs53.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs52.readFileSync(0, "utf-8");
+      rawPayload = fs53.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -46689,6 +46835,12 @@ async function runAgentMode() {
   if (envelopeUserRequest.trim()) {
     process.env.BLUMA_USER_REQUEST = envelopeUserRequest.trim();
   }
+  if (envelope.from_agent?.trim()) {
+    process.env.BLUMA_FROM_AGENT = envelope.from_agent.trim();
+  }
+  if (envelope.action?.trim()) {
+    process.env.BLUMA_ACTION = envelope.action.trim();
+  }
   const eventBus = new EventEmitter7();
   const sessionId = registrySessionId || envelope.session_id || envelope.message_id || uuidv412();
   process.env.BLUMA_SESSION_ID = sessionId;
@@ -46878,9 +47030,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path58.dirname(fileURLToPath8(import.meta.url));
-    const pkgPath = path58.join(base, "..", "package.json");
-    const j = JSON.parse(fs52.readFileSync(pkgPath, "utf8"));
+    const base = path59.dirname(fileURLToPath8(import.meta.url));
+    const pkgPath = path59.join(base, "..", "package.json");
+    const j = JSON.parse(fs53.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -47006,7 +47158,7 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs52.readFileSync(filePath, "utf-8");
+  const rawPayload = fs53.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
   const sessionId = envelope.session_id || envelope.message_id || uuidv412();
   registerSession({