npm - @nomad-e/bluma-cli - Versions diffs - 0.18.0 → 0.20.0 - Mend

@nomad-e/bluma-cli 0.18.0 → 0.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/config/skills/factorai-sh/SKILL.md +5 -5
package/dist/main.js +617 -273
package/package.json +1 -1

package/dist/main.js CHANGED Viewed

@@ -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
@@ -20269,7 +20269,7 @@ async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
       name: data.name,
       status: data.status || "building",
       url: appContext.appUrl || severinoUrl.replace(/\/$/, "") + `/app/${resolvedAppId}`,
-      message: data.message || "Deploy iniciado",
+      message: data.message || "Deploy iniciado. Chama factorai.sh.get_app_status({ appId, wait: true }) at\xE9 status ready ou failed; se failed, l\xEA typescriptErrors/buildLogTail e corrige o c\xF3digo.",
       isRedeploy: !!appId,
       appContext
     };
@@ -20413,6 +20413,102 @@ async function deployApp(args) {
   }
 }
+// src/app/agent/runtime/factorai_deploy_feedback.ts
+var FAILED_STATUSES = /* @__PURE__ */ new Set(["failed", "error", "build_failed"]);
+var READY_STATUSES = /* @__PURE__ */ new Set(["ready", "running", "live"]);
+var BUILDING_STATUSES = /* @__PURE__ */ new Set(["building", "deploying", "installing", "pending"]);
+function extractTypeScriptErrors(logText) {
+  if (!logText.trim()) return [];
+  const lines = logText.split("\n");
+  const blocks = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("Type error:") || line.includes("Failed to compile") || /^\s*>\s*\d+\s*\|/.test(line)) {
+      const start = Math.max(0, i - 3);
+      const end = Math.min(lines.length, i + 8);
+      blocks.push(lines.slice(start, end).join("\n").trim());
+    }
+  }
+  return [...new Set(blocks)].slice(0, 6);
+}
+function normalizeFactorAiAppStatus(raw, appId) {
+  const envelope = raw && typeof raw === "object" ? raw : {};
+  const data = envelope.data && typeof envelope.data === "object" && !Array.isArray(envelope.data) ? envelope.data : envelope;
+  const status = String(data.status ?? "unknown").toLowerCase();
+  const logs = typeof data.logs === "string" ? data.logs : "";
+  const logTail = logs.length > 12e3 ? logs.slice(-12e3) : logs;
+  const lastError = typeof data.lastError === "string" && data.lastError || typeof data.error === "string" && data.error || void 0;
+  const slug = typeof data.slug === "string" ? data.slug : void 0;
+  const url = typeof data.url === "string" ? data.url : void 0;
+  const tsErrors = extractTypeScriptErrors(logTail);
+  if (FAILED_STATUSES.has(status) || lastError) {
+    const error = lastError || tsErrors[0] || (logTail.includes("next build falhou") ? logTail.split("\n").slice(-5).join("\n") : "") || "Deploy/build failed on FactorAI.sh";
+    return {
+      success: false,
+      terminal: true,
+      status: "failed",
+      appId,
+      slug,
+      url,
+      error,
+      buildLogTail: logTail || void 0,
+      typescriptErrors: tsErrors.length > 0 ? tsErrors : void 0,
+      agentGuidance: "O build falhou no servidor. Corrige os erros TypeScript/compila\xE7\xE3o no projeto local (ex.: components/ui/card.tsx), confirma com npx tsc --noEmit se poss\xEDvel, depois factorai.sh.apply_app_changes ou deploy_app. N\xE3o digas ao utilizador que a app est\xE1 online."
+    };
+  }
+  if (READY_STATUSES.has(status)) {
+    return {
+      success: true,
+      terminal: true,
+      status: "ready",
+      appId,
+      slug,
+      url,
+      buildLogTail: logTail || void 0
+    };
+  }
+  if (BUILDING_STATUSES.has(status)) {
+    return {
+      success: true,
+      terminal: false,
+      status,
+      appId,
+      slug,
+      url,
+      buildLogTail: logTail || void 0
+    };
+  }
+  return {
+    success: true,
+    terminal: false,
+    status,
+    appId,
+    slug,
+    url,
+    buildLogTail: logTail || void 0
+  };
+}
+function formatFactorAiDeployStatusForAgent(result) {
+  const lines = [`status=${result.status}`, `appId=${result.appId}`];
+  if (result.slug) lines.push(`slug=${result.slug}`);
+  if (result.url) lines.push(`url=${result.url}`);
+  if (result.error) lines.push(`error=${result.error}`);
+  if (result.typescriptErrors?.length) {
+    lines.push("typescriptErrors:");
+    for (const block of result.typescriptErrors) {
+      lines.push(block);
+    }
+  } else if (result.buildLogTail) {
+    lines.push("buildLogTail:");
+    lines.push(result.buildLogTail);
+  }
+  if (result.agentGuidance) lines.push(`guidance=${result.agentGuidance}`);
+  return lines.join("\n");
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 // src/app/agent/runtime/native_tool_catalog.ts
 init_sandbox_policy();
 function getFactorAiBaseUrl() {
@@ -20494,9 +20590,81 @@ async function resolveFactorAiAppId(explicitAppId) {
     "appId em falta: passa o UUID de factorai.sh.json (appContext.appId) ou faz deploy_app primeiro nesta sess\xE3o."
   );
 }
+function isFactorAiNotFoundError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /not found/i.test(msg) || /404/.test(msg);
+}
+async function fetchAndNormalizeAppStatus(appId) {
+  const payload = await requestFactorAi(`/api/v1/apps/${encodeURIComponent(appId)}`);
+  return normalizeFactorAiAppStatus(payload, appId);
+}
 async function factorAiGetAppStatus(args) {
   const appId = await resolveFactorAiAppId(args?.appId);
-  return requestFactorAi(`/api/v1/apps/${encodeURIComponent(appId)}`);
+  const wait = args?.wait === true;
+  const timeoutMs = Math.max(5, args?.timeoutSeconds ?? 480) * 1e3;
+  const pollMs = Math.max(2, args?.pollIntervalSeconds ?? 5) * 1e3;
+  const deadline = Date.now() + timeoutMs;
+  const finalize = (result) => ({
+    success: true,
+    data: {
+      ...result,
+      summary: formatFactorAiDeployStatusForAgent(result)
+    }
+  });
+  if (!wait) {
+    try {
+      return finalize(await fetchAndNormalizeAppStatus(appId));
+    } catch (err) {
+      if (isFactorAiNotFoundError(err)) {
+        return finalize({
+          success: false,
+          terminal: true,
+          status: "failed",
+          appId,
+          error: String(err instanceof Error ? err.message : err),
+          agentGuidance: "App n\xE3o encontrada no FactorAI.sh \u2014 o deploy provavelmente falhou e o registo foi limpo, ou o appId est\xE1 errado. L\xEA factorai.sh.json, confirma FACTORAI_BASE_URL=SEVERINO_URL, e faz deploy de novo ap\xF3s corrigir o c\xF3digo."
+        });
+      }
+      throw err;
+    }
+  }
+  let sawBuilding = false;
+  while (Date.now() < deadline) {
+    try {
+      const result = await fetchAndNormalizeAppStatus(appId);
+      if (!result.terminal && result.status !== "failed") {
+        sawBuilding = true;
+      }
+      if (result.terminal) {
+        if (result.status === "ready" && !sawBuilding) {
+          await sleep(pollMs);
+          continue;
+        }
+        return finalize(result);
+      }
+    } catch (err) {
+      if (isFactorAiNotFoundError(err)) {
+        return finalize({
+          success: false,
+          terminal: true,
+          status: "failed",
+          appId,
+          error: String(err instanceof Error ? err.message : err),
+          agentGuidance: "Deploy falhou: a app desapareceu do registry (build error no servidor). Corrige o c\xF3digo e volta a deploy_app."
+        });
+      }
+      throw err;
+    }
+    await sleep(pollMs);
+  }
+  return finalize({
+    success: true,
+    terminal: false,
+    status: "building",
+    appId,
+    error: `Timeout ap\xF3s ${Math.round(timeoutMs / 1e3)}s \xE0 espera de ready/failed`,
+    agentGuidance: "Continua a pollar get_app_status ou verifica logs no FactorAI.sh."
+  });
 }
 async function factorAiApplyAppChanges(args) {
   const appId = await resolveFactorAiAppId(args?.appId);
@@ -20512,7 +20680,13 @@ async function factorAiApplyAppChanges(args) {
     })
   });
   await persistFactorAiWorkspaceManifestFromResponse(response);
-  return response;
+  const normalized = normalizeFactorAiAppStatus(response, appId);
+  const summary = formatFactorAiDeployStatusForAgent(normalized);
+  const message2 = args?.deploy !== false && !normalized.terminal ? "Changes accepted; build em curso. Chama factorai.sh.get_app_status({ wait: true }) at\xE9 ready ou failed." : normalized.success ? "Changes applied" : normalized.error;
+  return {
+    success: true,
+    data: { ...normalized, summary, message: message2 }
+  };
 }
 async function factorAiRedeployApp(args) {
   const appId = await resolveFactorAiAppId(args?.appId);
@@ -20520,7 +20694,13 @@ async function factorAiRedeployApp(args) {
     method: "POST"
   });
   await persistFactorAiWorkspaceManifestFromResponse(response);
-  return response;
+  const normalized = normalizeFactorAiAppStatus(response, appId);
+  const summary = formatFactorAiDeployStatusForAgent(normalized);
+  const message2 = normalized.terminal ? normalized.success ? "Redeploy complete" : normalized.error : "Redeploy started; poll get_app_status({ wait: true }).";
+  return {
+    success: true,
+    data: { ...normalized, summary, message: message2 }
+  };
 }
 function extractFactorAiResponseData(response) {
   if (response && typeof response === "object" && response.data && typeof response.data === "object") {
@@ -20607,13 +20787,25 @@ function getFactorAiSandboxToolDefinitions() {
       type: "function",
       function: {
         name: "factorai.sh.get_app_status",
-        description: "Poll deploy/rebuild status (building|ready|failed). Call after deploy_app or apply_app_changes until ready before telling the user the app is live.",
+        description: "Poll deploy/rebuild status. On failed returns buildLogTail + typescriptErrors so you can fix code. Use wait:true after deploy_app/apply_app_changes until ready or failed before message(result).",
         parameters: {
           type: "object",
           properties: {
             appId: {
               type: "string",
               description: "UUID from factorai.sh.json (appContext.appId). Optional if manifest exists in cwd. Do not use URL slug."
+            },
+            wait: {
+              type: "boolean",
+              description: "If true, poll until ready/failed/timeout (recommended after deploy)."
+            },
+            timeoutSeconds: {
+              type: "number",
+              description: "Max wait time when wait=true (default 480)."
+            },
+            pollIntervalSeconds: {
+              type: "number",
+              description: "Seconds between polls when wait=true (default 5)."
             }
           },
           required: [],
@@ -21836,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
@@ -23700,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>`;
@@ -23715,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");
   }
 }
@@ -23731,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.
@@ -23791,11 +23983,11 @@ Use \`factorai.sh.redeploy_app({ appId })\` only when sources on the server are
 ## Polling after deploy / apply_app_changes
-1. \`factorai.sh.get_app_status({ appId })\` or GET \`/api/v1/apps/{appId}\`.
+1. **Always** \`factorai.sh.get_app_status({ appId, wait: true })\` after \`deploy_app\` or \`apply_app_changes\` (polls at\xE9 \`ready\` ou \`failed\`).
 2. Expect \`status: "building"\` during \`npm install\` / \`next build\` (~30\u201390s).
-3. **Do not** report "live" on the first \`ready\` if you have not seen \`building\` since this operation \u2014 stale \`ready\` can appear briefly.
-4. Wait until \`status\` is \`ready\` (or \`running\` / \`live\`) **after** a \`building\` phase, then verify the public route returns HTML (not \`Service Unavailable\`).
-5. On \`failed\` / \`error\`: read server/build logs if available; fix TS/scaffold issues; retry \`apply_app_changes\` or \`redeploy_app\`.
+3. **Do not** report "live" until \`success: true\` and \`status: "ready"\` no resultado do \`get_app_status\`.
+4. On \`success: false\` / \`status: "failed"\`: read \`typescriptErrors\`, \`buildLogTail\`, and \`summary\` from the tool result \u2014 fix the code like a human reading the Next build log, then \`apply_app_changes\` or \`deploy_app\` again.
+5. Never ignore deploy failures; never tell the user the app is online when \`get_app_status\` returned \`failed\`.
 ---
@@ -23821,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;
@@ -23852,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";
@@ -23882,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";
@@ -23893,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";
@@ -23901,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";
     }
@@ -23918,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;
   }
@@ -24130,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(),
@@ -24155,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)
@@ -24174,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 += `
@@ -25353,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;
@@ -25371,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)`;
@@ -25430,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;
   }
@@ -25453,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;
     }
@@ -25492,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;
     }
@@ -25521,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;
@@ -25538,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({
@@ -25556,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";
@@ -25571,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") {
@@ -25584,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") {
@@ -25801,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, " ");
@@ -25815,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}` };
   }
@@ -25861,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}` };
   }
@@ -26367,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;
 }
@@ -27239,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",
@@ -27266,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 };
@@ -27279,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}` };
@@ -27288,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" };
@@ -27326,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;
       }
     }
@@ -27794,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);
     }
@@ -28006,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}`;
@@ -28741,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
@@ -28807,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 [];
@@ -29359,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 });
       }
     }
@@ -29375,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);
@@ -29402,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;
@@ -31258,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();
@@ -31269,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
@@ -31289,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;
@@ -31910,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;
   }
@@ -33241,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;
@@ -33924,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,
@@ -33968,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);
@@ -33978,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: [
@@ -34370,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 }) {
@@ -34896,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) {
@@ -34911,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 "";
   }
@@ -37853,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) {
@@ -37862,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"];
@@ -37879,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 {
@@ -37888,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());
@@ -37905,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;
       }
@@ -38112,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";
@@ -38243,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",
@@ -38262,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;
     }
   }
@@ -38312,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 {
   }
@@ -38339,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);
       }
@@ -38371,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";
@@ -38400,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;
@@ -38472,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) {
@@ -38487,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;
@@ -38509,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`
   );
@@ -38531,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 {
@@ -38556,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;
       }
@@ -38567,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;
@@ -38586,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`
     );
@@ -38627,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 " }) });
@@ -38794,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",
@@ -40962,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();
@@ -40988,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 ====================
@@ -40998,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() });
     }
@@ -41030,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() };
@@ -41041,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 ====================
@@ -41112,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({
@@ -41167,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({
@@ -41240,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;
     }
@@ -41263,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;
     }
@@ -41288,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);
@@ -41298,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;
@@ -41336,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
@@ -41360,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,
@@ -41395,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);
   }
@@ -43832,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) };
@@ -43849,7 +44187,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path55.dirname(dir);
+    const parent = path56.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -43858,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 {
   }
@@ -43872,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 {
     }
@@ -44696,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) {
@@ -44724,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);
@@ -45997,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("/");
@@ -46021,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;
@@ -46051,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;
   }
@@ -46068,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")) {
@@ -46078,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) => {
@@ -46443,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, {
@@ -46497,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;
@@ -46686,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";
@@ -46814,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({