@nomad-e/bluma-cli 0.10.0 → 0.11.0

package/dist/main.js

@@ -406,11 +406,11 @@ var init_sandbox_policy = __esm({
 });
 
 // src/app/agent/runtime/task_store.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 function getStorePath() {
   const policy = getSandboxPolicy();
-  return path8.join(policy.workspaceRoot, ".bluma", "task_state.json");
+  return path9.join(policy.workspaceRoot, ".bluma", "task_state.json");
 }
 function getDefaultState() {
   return {
@@ -426,8 +426,8 @@ function ensureLoaded() {
     return cache2;
   }
   try {
-    if (fs9.existsSync(storePath)) {
-      const raw = fs9.readFileSync(storePath, "utf-8");
+    if (fs10.existsSync(storePath)) {
+      const raw = fs10.readFileSync(storePath, "utf-8");
       const parsed = JSON.parse(raw);
       cache2 = {
         tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
@@ -446,9 +446,9 @@ function ensureLoaded() {
 }
 function persist(state2) {
   const storePath = getStorePath();
-  fs9.mkdirSync(path8.dirname(storePath), { recursive: true });
+  fs10.mkdirSync(path9.dirname(storePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs9.writeFileSync(storePath, JSON.stringify(state2, null, 2), "utf-8");
+  fs10.writeFileSync(storePath, JSON.stringify(state2, null, 2), "utf-8");
   cache2 = state2;
   cachePath = storePath;
 }
@@ -835,37 +835,37 @@ __export(session_registry_exports, {
   removeSession: () => removeSession,
   updateSession: () => updateSession
 });
-import fs15 from "fs";
+import fs16 from "fs";
 import os11 from "os";
-import path16 from "path";
+import path17 from "path";
 function getRegistryDir() {
-  return path16.join(process.env.HOME || os11.homedir(), ".bluma", "registry");
+  return path17.join(process.env.HOME || os11.homedir(), ".bluma", "registry");
 }
 function getRegistryFile() {
-  return path16.join(getRegistryDir(), "sessions.json");
+  return path17.join(getRegistryDir(), "sessions.json");
 }
 function ensureRegistryDir() {
-  fs15.mkdirSync(getRegistryDir(), { recursive: true });
+  fs16.mkdirSync(getRegistryDir(), { recursive: true });
 }
 function readRegistry() {
   ensureRegistryDir();
   const file = getRegistryFile();
-  if (!fs15.existsSync(file)) {
+  if (!fs16.existsSync(file)) {
     return { entries: [] };
   }
   try {
-    return JSON.parse(fs15.readFileSync(file, "utf-8"));
+    return JSON.parse(fs16.readFileSync(file, "utf-8"));
   } catch {
     return { entries: [] };
   }
 }
 function writeRegistry(state2) {
   ensureRegistryDir();
-  fs15.writeFileSync(getRegistryFile(), JSON.stringify(state2, null, 2), "utf-8");
+  fs16.writeFileSync(getRegistryFile(), JSON.stringify(state2, null, 2), "utf-8");
 }
 function getSessionLogPath(sessionId) {
   ensureRegistryDir();
-  return path16.join(getRegistryDir(), `${sessionId}.jsonl`);
+  return path17.join(getRegistryDir(), `${sessionId}.jsonl`);
 }
 function registerSession(entry) {
   const state2 = readRegistry();
@@ -910,13 +910,13 @@ function removeSession(sessionId) {
 }
 function appendSessionLog(sessionId, payload) {
   const logFile = getSessionLogPath(sessionId);
-  fs15.appendFileSync(logFile, `${JSON.stringify(payload)}
+  fs16.appendFileSync(logFile, `${JSON.stringify(payload)}
 `, "utf-8");
 }
 function readSessionLog(sessionId) {
   const logFile = getSessionLogPath(sessionId);
-  if (!fs15.existsSync(logFile)) return [];
-  return fs15.readFileSync(logFile, "utf-8").split("\n").filter(Boolean);
+  if (!fs16.existsSync(logFile)) return [];
+  return fs16.readFileSync(logFile, "utf-8").split("\n").filter(Boolean);
 }
 var init_session_registry = __esm({
   "src/app/agent/runtime/session_registry.ts"() {
@@ -925,17 +925,17 @@ var init_session_registry = __esm({
 });
 
 // src/app/agent/utils/logger.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import os12 from "os";
-import path17 from "path";
+import path18 from "path";
 function getLogDir() {
-  const dir = path17.join(process.env.HOME || os12.homedir(), ".bluma", "logs");
-  fs16.mkdirSync(dir, { recursive: true });
+  const dir = path18.join(process.env.HOME || os12.homedir(), ".bluma", "logs");
+  fs17.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function getLogFilePath() {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return path17.join(getLogDir(), `bluma-${today}.log`);
+  return path18.join(getLogDir(), `bluma-${today}.log`);
 }
 var BluMaLogger, logger;
 var init_logger = __esm({
@@ -965,7 +965,7 @@ var init_logger = __esm({
           turnId: this.turnId
         };
         try {
-          fs16.appendFileSync(this.logFile, JSON.stringify(logEntry) + "\n");
+          fs17.appendFileSync(this.logFile, JSON.stringify(logEntry) + "\n");
         } catch {
         }
         if (this.consoleEnabled) {
@@ -1066,19 +1066,19 @@ __export(mailbox_registry_exports, {
   sendSignal: () => sendSignal,
   sendToMailbox: () => sendToMailbox
 });
-import fs17 from "fs";
+import fs18 from "fs";
 import os13 from "os";
-import path18 from "path";
+import path19 from "path";
 import { EventEmitter as EventEmitter3 } from "events";
 import { v4 as uuidv45 } from "uuid";
 function getMailboxesDir() {
   if (mailboxesDir) return mailboxesDir;
-  mailboxesDir = path18.join(process.env.HOME || os13.homedir(), ".bluma", "mailboxes");
-  fs17.mkdirSync(mailboxesDir, { recursive: true });
+  mailboxesDir = path19.join(process.env.HOME || os13.homedir(), ".bluma", "mailboxes");
+  fs18.mkdirSync(mailboxesDir, { recursive: true });
   return mailboxesDir;
 }
 function getMailboxPath(sessionId, type) {
-  return path18.join(getMailboxesDir(), `${sessionId}.${type}`);
+  return path19.join(getMailboxesDir(), `${sessionId}.${type}`);
 }
 function sendToMailbox(sessionId, type, message2) {
   return mailbox.sendToMailbox(sessionId, type, message2);
@@ -1104,7 +1104,7 @@ function pruneMailbox(sessionId, type, keepLast = 100) {
   const pruned = queue.slice(-keepLast);
   mailbox.queues.set(sessionId, pruned);
   const filePath = getMailboxPath(sessionId, type);
-  fs17.writeFileSync(filePath, pruned.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
+  fs18.writeFileSync(filePath, pruned.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
 }
 function listActiveMailboxes() {
   const result = [];
@@ -1172,16 +1172,16 @@ var init_mailbox_registry = __esm({
       loadExistingMailboxes() {
         try {
           const dir = getMailboxesDir();
-          const files = fs17.readdirSync(dir);
+          const files = fs18.readdirSync(dir);
           for (const file of files) {
             if (!file.endsWith(".in") && !file.endsWith(".out") && !file.endsWith(".sig")) {
               continue;
             }
             const type = file.split(".").pop();
             const sessionId = file.slice(0, -(type.length + 1));
-            const filePath = path18.join(dir, file);
+            const filePath = path19.join(dir, file);
             try {
-              const content = fs17.readFileSync(filePath, "utf-8");
+              const content = fs18.readFileSync(filePath, "utf-8");
               const lines = content.trim().split("\n").filter(Boolean);
               const messages = [];
               for (const line of lines) {
@@ -1218,7 +1218,7 @@ var init_mailbox_registry = __esm({
         this.queues.set(sessionId, queue);
         try {
           const filePath = getMailboxPath(sessionId, type);
-          fs17.appendFileSync(filePath, JSON.stringify(fullMessage) + "\n", "utf-8");
+          fs18.appendFileSync(filePath, JSON.stringify(fullMessage) + "\n", "utf-8");
         } catch {
         }
         this.emit(`message:${sessionId}`, fullMessage);
@@ -1267,7 +1267,7 @@ var init_mailbox_registry = __esm({
         this.emit(`signal:${sessionId}`, signal);
         try {
           const filePath = getMailboxPath(sessionId, "sig");
-          fs17.appendFileSync(filePath, JSON.stringify(signal) + "\n", "utf-8");
+          fs18.appendFileSync(filePath, JSON.stringify(signal) + "\n", "utf-8");
         } catch {
         }
         return signal.id;
@@ -1281,9 +1281,9 @@ var init_mailbox_registry = __esm({
       ensureMailbox(sessionId) {
         const dir = getMailboxesDir();
         for (const type of ["in", "out", "sig"]) {
-          const filePath = path18.join(dir, `${sessionId}.${type}`);
-          if (!fs17.existsSync(filePath)) {
-            fs17.writeFileSync(filePath, "", "utf-8");
+          const filePath = path19.join(dir, `${sessionId}.${type}`);
+          if (!fs18.existsSync(filePath)) {
+            fs18.writeFileSync(filePath, "", "utf-8");
           }
         }
       }
@@ -1293,8 +1293,8 @@ var init_mailbox_registry = __esm({
       removeMailbox(sessionId) {
         const dir = getMailboxesDir();
         for (const type of ["in", "out", "sig"]) {
-          const filePath = path18.join(dir, `${sessionId}.${type}`);
-          if (fs17.existsSync(filePath)) fs17.unlinkSync(filePath);
+          const filePath = path19.join(dir, `${sessionId}.${type}`);
+          if (fs18.existsSync(filePath)) fs18.unlinkSync(filePath);
         }
         this.queues.delete(sessionId);
         this.signalQueues.delete(sessionId);
@@ -1313,9 +1313,9 @@ __export(AgentCoordinationTool_exports, {
   spawnAgent: () => spawnAgent,
   waitAgent: () => waitAgent
 });
-import fs18 from "fs";
+import fs19 from "fs";
 import os14 from "os";
-import path19 from "path";
+import path20 from "path";
 import { spawn as spawn3 } from "child_process";
 import { v4 as uuidv46 } from "uuid";
 function readUserContextFromEnv() {
@@ -1429,10 +1429,10 @@ async function spawnAgent(args) {
     spawnLog.error("Payload NOT serializable", { error: e.message });
     throw new BluMaError("WORKER_CONTEXT_NOT_SERIALIZABLE" /* WORKER_CONTEXT_NOT_SERIALIZABLE */, `Worker context is not JSON-serializable: ${e.message}`);
   }
-  const payloadDir = fs18.mkdtempSync(path19.join(os14.tmpdir(), "bluma-worker-"));
-  const payloadPath = path19.join(payloadDir, `${sessionId}.json`);
+  const payloadDir = fs19.mkdtempSync(path20.join(os14.tmpdir(), "bluma-worker-"));
+  const payloadPath = path20.join(payloadDir, `${sessionId}.json`);
   try {
-    fs18.writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
+    fs19.writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
     spawnLog.debug("Payload written", { payloadPath });
   } catch (e) {
     spawnLog.error("Failed to write payload", { error: e.message, payloadPath });
@@ -2201,11 +2201,11 @@ var NodeFsOperations = {
       if (fd) fs.closeSync(fd);
     }
   },
-  appendFileSync(path54, data, options) {
-    const _ = slowLogging`fs.appendFileSync(${path54}, ${data.length} chars)`;
+  appendFileSync(path56, data, options) {
+    const _ = slowLogging`fs.appendFileSync(${path56}, ${data.length} chars)`;
     if (options?.mode !== void 0) {
       try {
-        const fd = fs.openSync(path54, "ax", options.mode);
+        const fd = fs.openSync(path56, "ax", options.mode);
         try {
           fs.appendFileSync(fd, data);
         } finally {
@@ -2216,35 +2216,35 @@ var NodeFsOperations = {
         if (getErrnoCode(e) !== "EEXIST") throw e;
       }
     }
-    fs.appendFileSync(path54, data);
+    fs.appendFileSync(path56, data);
   },
   copyFileSync(src, dest) {
     const _ = slowLogging`fs.copyFileSync(${src} → ${dest})`;
     fs.copyFileSync(src, dest);
   },
-  unlinkSync(path54) {
-    const _ = slowLogging`fs.unlinkSync(${path54})`;
-    fs.unlinkSync(path54);
+  unlinkSync(path56) {
+    const _ = slowLogging`fs.unlinkSync(${path56})`;
+    fs.unlinkSync(path56);
   },
   renameSync(oldPath, newPath) {
     const _ = slowLogging`fs.renameSync(${oldPath} → ${newPath})`;
     fs.renameSync(oldPath, newPath);
   },
-  linkSync(target, path54) {
-    const _ = slowLogging`fs.linkSync(${target} → ${path54})`;
-    fs.linkSync(target, path54);
+  linkSync(target, path56) {
+    const _ = slowLogging`fs.linkSync(${target} → ${path56})`;
+    fs.linkSync(target, path56);
   },
-  symlinkSync(target, path54, type) {
-    const _ = slowLogging`fs.symlinkSync(${target} → ${path54})`;
-    fs.symlinkSync(target, path54, type);
+  symlinkSync(target, path56, type) {
+    const _ = slowLogging`fs.symlinkSync(${target} → ${path56})`;
+    fs.symlinkSync(target, path56, type);
   },
-  readlinkSync(path54) {
-    const _ = slowLogging`fs.readlinkSync(${path54})`;
-    return fs.readlinkSync(path54);
+  readlinkSync(path56) {
+    const _ = slowLogging`fs.readlinkSync(${path56})`;
+    return fs.readlinkSync(path56);
   },
-  realpathSync(path54) {
-    const _ = slowLogging`fs.realpathSync(${path54})`;
-    return fs.realpathSync(path54).normalize("NFC");
+  realpathSync(path56) {
+    const _ = slowLogging`fs.realpathSync(${path56})`;
+    return fs.realpathSync(path56).normalize("NFC");
   },
   mkdirSync(dirPath, options) {
     const _ = slowLogging`fs.mkdirSync(${dirPath})`;
@@ -2277,12 +2277,12 @@ var NodeFsOperations = {
     const _ = slowLogging`fs.rmdirSync(${dirPath})`;
     fs.rmdirSync(dirPath);
   },
-  rmSync(path54, options) {
-    const _ = slowLogging`fs.rmSync(${path54})`;
-    fs.rmSync(path54, options);
+  rmSync(path56, options) {
+    const _ = slowLogging`fs.rmSync(${path56})`;
+    fs.rmSync(path56, options);
   },
-  createWriteStream(path54) {
-    return fs.createWriteStream(path54);
+  createWriteStream(path56) {
+    return fs.createWriteStream(path56);
   },
   async readFileBytes(fsPath, maxBytes) {
     if (maxBytes === void 0) {
@@ -2389,12 +2389,12 @@ function shouldLogDebugMessage(message2) {
 var hasFormattedOutput = false;
 var debugWriter = null;
 var pendingWrite = Promise.resolve();
-async function appendAsync(needMkdir, dir, path54, content) {
+async function appendAsync(needMkdir, dir, path56, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {
     });
   }
-  await appendFile(path54, content);
+  await appendFile(path56, content);
   void updateLatestDebugLogSymlink();
 }
 function noop() {
@@ -2404,8 +2404,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path54 = getDebugLogPath();
-        const dir = dirname(path54);
+        const path56 = getDebugLogPath();
+        const dir = dirname(path56);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -2415,11 +2415,11 @@ function getDebugWriter() {
             } catch {
             }
           }
-          getFsImplementation().appendFileSync(path54, content);
+          getFsImplementation().appendFileSync(path56, content);
           void updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path54, content)).catch(noop);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path56, content)).catch(noop);
       },
       flushIntervalMs: 1e3,
       maxBufferSize: 100,
@@ -8606,8 +8606,8 @@ import codeExcerpt from "code-excerpt";
 import { readFileSync as readFileSync2 } from "fs";
 import StackUtils from "stack-utils";
 import { jsx as jsx6, jsxs } from "react/jsx-runtime";
-var cleanupPath = (path54) => {
-  return path54?.replace(`file://${process.cwd()}/`, "");
+var cleanupPath = (path56) => {
+  return path56?.replace(`file://${process.cwd()}/`, "");
 };
 var stackUtils;
 function getStackUtils() {
@@ -12584,8 +12584,8 @@ var getInstance = (stdout, createInstance) => {
 
 // src/main.ts
 import { EventEmitter as EventEmitter7 } from "events";
-import fs49 from "fs";
-import path53 from "path";
+import fs51 from "fs";
+import path55 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
@@ -13479,7 +13479,7 @@ function cancelSlashSubmenu() {
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path44 from "path";
+import path46 from "path";
 import os31 from "os";
 
 // src/app/agent/tool_invoker.ts
@@ -14028,10 +14028,173 @@ ${finalDiff}`,
 // src/app/agent/tools/MessageTool/MessageTool.ts
 import { v4 as uuidv42 } from "uuid";
 
-// src/app/agent/runtime/sandbox_message_validation.ts
-init_sandbox_policy();
+// src/app/agent/runtime/factorai_context.ts
 import fs5 from "fs";
 import path5 from "path";
+function normalizeContext(raw) {
+  if (!raw || typeof raw.appId !== "string" || !raw.appId.trim()) {
+    return null;
+  }
+  const appId = raw.appId.trim();
+  return {
+    appId,
+    tenantId: typeof raw.tenantId === "string" ? raw.tenantId : null,
+    projectId: typeof raw.projectId === "string" ? raw.projectId : null,
+    workspaceId: typeof raw.workspaceId === "string" ? raw.workspaceId : null,
+    revisionId: typeof raw.revisionId === "string" ? raw.revisionId : null,
+    deploymentId: typeof raw.deploymentId === "string" ? raw.deploymentId : null,
+    buildJobId: typeof raw.buildJobId === "string" ? raw.buildJobId : null,
+    manifestPath: typeof raw.manifestPath === "string" ? raw.manifestPath : null,
+    manifestFile: typeof raw.manifestFile === "string" ? raw.manifestFile : null,
+    appUrl: typeof raw.appUrl === "string" ? raw.appUrl : null
+  };
+}
+function readJsonFile(filePath) {
+  try {
+    if (!fs5.existsSync(filePath)) {
+      return null;
+    }
+    const parsed = JSON.parse(fs5.readFileSync(filePath, "utf8"));
+    if (parsed && typeof parsed === "object") {
+      return parsed.appContext && typeof parsed.appContext === "object" ? parsed.appContext : parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readFactorAiWorkspaceManifest(projectDir = process.cwd()) {
+  const manifestPath = path5.join(projectDir, "factorai.sh.json");
+  try {
+    if (!fs5.existsSync(manifestPath)) {
+      return null;
+    }
+    const parsed = JSON.parse(fs5.readFileSync(manifestPath, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readContextFromWorkspace() {
+  const candidate = path5.join(process.cwd(), "factorai.sh.json");
+  const parsed = readJsonFile(candidate);
+  if (!parsed) {
+    return null;
+  }
+  const context = normalizeContext(parsed);
+  return context;
+}
+function loadFactorAiAppContext() {
+  return readContextFromWorkspace();
+}
+var FACTOR_SH_URL_APP_FIELD = "factor-sh-url-app";
+function resolveFactorShAppLiveUrl(projectDir = process.cwd()) {
+  const manifest = readFactorAiWorkspaceManifest(projectDir);
+  const raw = manifest?.appContext?.appUrl ?? (typeof manifest?.app?.url === "string" ? manifest.app.url : null);
+  if (typeof raw !== "string" || !raw.trim()) {
+    return null;
+  }
+  const url = raw.trim();
+  if (/^https?:\/\//i.test(url)) {
+    return url;
+  }
+  const base = (process.env.SEVERINO_URL || process.env.FACTORAI_BASE_URL || process.env.FACTORAI_URL || "").trim().replace(/\/$/, "");
+  if (!base) {
+    return url.startsWith("/") ? url : `/${url}`;
+  }
+  return `${base}${url.startsWith("/") ? url : `/${url}`}`;
+}
+function formatFactorAiAppContextSummary(context) {
+  if (!context) {
+    return "";
+  }
+  const parts = [
+    `appId=${context.appId}`,
+    context.tenantId ? `tenantId=${context.tenantId}` : null,
+    context.projectId ? `projectId=${context.projectId}` : null,
+    context.workspaceId ? `workspaceId=${context.workspaceId}` : null,
+    context.revisionId ? `revisionId=${context.revisionId}` : null,
+    context.deploymentId ? `deploymentId=${context.deploymentId}` : null,
+    context.buildJobId ? `buildJobId=${context.buildJobId}` : null,
+    context.appUrl ? `appUrl=${context.appUrl}` : null
+  ].filter(Boolean);
+  return parts.join(" | ");
+}
+function buildFactorAiWorkspaceManifest(input) {
+  const projectDir = input.projectDir || process.cwd();
+  const existing = readFactorAiWorkspaceManifest(projectDir) || {};
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const nextAppContext = {
+    ...typeof existing.appContext === "object" && existing.appContext ? existing.appContext : {},
+    appId: input.appContext.appId,
+    tenantId: input.appContext.tenantId ?? null,
+    projectId: input.appContext.projectId ?? null,
+    workspaceId: input.appContext.workspaceId ?? null,
+    revisionId: input.appContext.revisionId ?? null,
+    deploymentId: input.appContext.deploymentId ?? null,
+    buildJobId: input.appContext.buildJobId ?? null,
+    manifestPath: "factorai.sh.json",
+    manifestFile: "factorai.sh.json",
+    appUrl: input.appContext.appUrl ?? null
+  };
+  return {
+    ...existing,
+    version: 1,
+    manifestFile: "factorai.sh.json",
+    manifestPath: "factorai.sh.json",
+    appContext: nextAppContext,
+    app: {
+      ...typeof existing.app === "object" && existing.app ? existing.app : {},
+      name: input.name ?? (typeof existing.app === "object" && existing.app ? existing.app.name : void 0) ?? null,
+      status: input.status ?? (typeof existing.app === "object" && existing.app ? existing.app.status : void 0) ?? "building",
+      isRedeploy: input.isRedeploy ?? (typeof existing.app === "object" && existing.app ? existing.app.isRedeploy : false),
+      message: input.message ?? (typeof existing.app === "object" && existing.app ? existing.app.message : null),
+      ...input.app || {}
+    },
+    agent: {
+      provider: "bluma",
+      mode: "tool-first",
+      instructions: [
+        "Read factorai.sh.json as the source of truth before editing files.",
+        "Load skill factorai-sh for the full FactorAI.sh workflow.",
+        "For an app already online: use factorai.sh.apply_app_changes with deploy:true (not deploy_app again).",
+        "Poll factorai.sh.get_app_status until building\u2192ready before reporting the live URL.",
+        "Use factorai.sh.redeploy_app only when rebuilding without new file patches."
+      ],
+      ...typeof existing.agent === "object" && existing.agent ? existing.agent : {},
+      ...input.agent || {}
+    },
+    sandbox: {
+      ...typeof existing.sandbox === "object" && existing.sandbox ? existing.sandbox : {},
+      ...input.sandbox || {}
+    },
+    source: {
+      root: ".",
+      publicDir: "./public",
+      appDir: ".",
+      ...typeof existing.source === "object" && existing.source ? existing.source : {},
+      ...input.source || {}
+    },
+    updatedAt: now2,
+    ...input.extra || {}
+  };
+}
+async function writeFactorAiWorkspaceManifest(input) {
+  const projectDir = input.projectDir || process.cwd();
+  const manifest = buildFactorAiWorkspaceManifest({ ...input, projectDir });
+  const manifestPath = path5.join(projectDir, "factorai.sh.json");
+  fs5.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return { manifestPath, manifest };
+}
+
+// src/app/agent/tools/MessageTool/MessageTool.ts
+init_sandbox_policy();
+
+// src/app/agent/runtime/sandbox_message_validation.ts
+init_sandbox_policy();
+import fs6 from "fs";
+import path6 from "path";
 var HTTP_URL_PATTERN = /^https?:\/\//i;
 function normalizeAttachmentPath(entry) {
   if (typeof entry === "string") {
@@ -14104,14 +14267,14 @@ function validateSandboxMessageDeliverables(args, policy = getSandboxPolicy(), o
         details: err instanceof Error ? err.message : String(err)
       };
     }
-    if (!fs5.existsSync(resolved)) {
+    if (!fs6.existsSync(resolved)) {
       return {
         ok: false,
         error: "Attachment file does not exist",
         details: `Create the deliverable first (file_write \u2192 .bluma/artifacts/...). Missing: ${resolved}`
       };
     }
-    const stat = fs5.statSync(resolved);
+    const stat = fs6.statSync(resolved);
     if (!stat.isFile()) {
       return {
         ok: false,
@@ -14124,7 +14287,7 @@ function validateSandboxMessageDeliverables(args, policy = getSandboxPolicy(), o
       return {
         ok: false,
         error: "Files are delivered only via .bluma/artifacts/",
-        details: `Move or copy the deliverable to ${path5.relative(policy.workspaceRoot, artifactsDir2)}/ and pass that path in attachments[]. Rejected: ${raw}`
+        details: `Move or copy the deliverable to ${path6.relative(policy.workspaceRoot, artifactsDir2)}/ and pass that path in attachments[]. Rejected: ${raw}`
       };
     }
   }
@@ -14159,18 +14322,25 @@ function normalizeMessageToolArgs(raw) {
       attachments = [rawAttachments.trim()];
     }
   }
+  const rawUrl = raw[FACTOR_SH_URL_APP_FIELD] ?? raw.factor_sh_url_app ?? raw.factoraiShUrlApp ?? raw.factorai_sh_url_app;
+  const factorShUrlApp = typeof rawUrl === "string" && rawUrl.trim() ? rawUrl.trim() : void 0;
   return {
     content,
     message_type,
-    attachments: attachments?.length ? attachments : void 0
+    attachments: attachments?.length ? attachments : void 0,
+    factorShUrlApp
   };
 }
 
 // src/app/agent/tools/MessageTool/MessageTool.ts
 function message(args) {
-  const { content, message_type, attachments } = normalizeMessageToolArgs(
+  const { content, message_type, attachments, factorShUrlApp } = normalizeMessageToolArgs(
     args
   );
+  let resolvedFactorShUrl = factorShUrlApp;
+  if (message_type === "result" && getSandboxPolicy().isSandbox && !resolvedFactorShUrl) {
+    resolvedFactorShUrl = resolveFactorShAppLiveUrl() ?? void 0;
+  }
   const deliverableCheck = validateSandboxMessageDeliverables(
     {
       message_type,
@@ -14198,6 +14368,7 @@ function message(args) {
       body: content
     },
     attachments: Array.isArray(attachments) ? attachments : void 0,
+    ...resolvedFactorShUrl ? { [FACTOR_SH_URL_APP_FIELD]: resolvedFactorShUrl } : {},
     success: true,
     delivered: true
   };
@@ -14205,8 +14376,8 @@ function message(args) {
 }
 
 // src/app/agent/tools/LsTool/LsTool.ts
-import { promises as fs6 } from "fs";
-import path6 from "path";
+import { promises as fs7 } from "fs";
+import path7 from "path";
 import os5 from "os";
 import { minimatch } from "minimatch";
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
@@ -14226,7 +14397,7 @@ var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
 ]);
 function expandPath(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path6.join(os5.homedir(), p.slice(2));
+    return path7.join(os5.homedir(), p.slice(2));
   }
   return p;
 }
@@ -14252,8 +14423,8 @@ async function ls(args) {
     max_depth
   } = args;
   try {
-    const basePath = path6.resolve(expandPath(directory_path));
-    const stat = await fs6.stat(basePath).catch(() => null);
+    const basePath = path7.resolve(expandPath(directory_path));
+    const stat = await fs7.stat(basePath).catch(() => null);
     if (!stat || !stat.isDirectory()) {
       throw new Error(`Directory '${directory_path}' not found.`);
     }
@@ -14265,11 +14436,11 @@ async function ls(args) {
     const allDirs = [];
     const walk = async (currentDir, currentDepth) => {
       if (max_depth !== void 0 && currentDepth >= max_depth) return;
-      const entries = await fs6.readdir(currentDir, { withFileTypes: true });
+      const entries = await fs7.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         const entryName = entry.name;
-        const fullPath = path6.join(currentDir, entryName);
-        const relativePath = path6.relative(basePath, fullPath).split(path6.sep).join("/");
+        const fullPath = path7.join(currentDir, entryName);
+        const relativePath = path7.relative(basePath, fullPath).split(path7.sep).join("/");
         const isHidden = entryName.startsWith(".");
         if (shouldIgnore(entryName, allIgnorePatterns) || isHidden && !show_hidden) {
           continue;
@@ -14278,7 +14449,7 @@ async function ls(args) {
           allDirs.push(relativePath);
           if (recursive) await walk(fullPath, currentDepth + 1);
         } else if (entry.isFile()) {
-          if (!normalizedExtensions || normalizedExtensions.includes(path6.extname(entryName).toLowerCase())) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path7.extname(entryName).toLowerCase())) {
             allFiles.push(relativePath);
           }
         }
@@ -14291,7 +14462,7 @@ async function ls(args) {
     const dirEnd = end_index ?? allDirs.length;
     return {
       success: true,
-      path: basePath.split(path6.sep).join("/"),
+      path: basePath.split(path7.sep).join("/"),
       recursive,
       total_files: allFiles.length,
       total_directories: allDirs.length,
@@ -14313,13 +14484,13 @@ async function ls(args) {
 
 // src/app/agent/tools/ReadLinesTool/ReadLinesTool.ts
 init_sandbox_policy();
-import { promises as fs7 } from "fs";
-import path7 from "path";
+import { promises as fs8 } from "fs";
+import path8 from "path";
 import os6 from "os";
 var DEFAULT_LINE_WINDOW = 2e3;
 function expandPath2(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path7.join(os6.homedir(), p.slice(2));
+    return path8.join(os6.homedir(), p.slice(2));
   }
   return p;
 }
@@ -14337,7 +14508,7 @@ async function readLines(args) {
   }
   try {
     const resolvedPath = resolveWorkspacePath(expandPath2(filepath));
-    const stat = await fs7.stat(resolvedPath).catch(() => null);
+    const stat = await fs8.stat(resolvedPath).catch(() => null);
     if (!stat || !stat.isFile()) {
       const workspaceRoot = resolveWorkspacePath(".");
       const isInsideWorkspace = resolvedPath.startsWith(workspaceRoot);
@@ -14356,7 +14527,7 @@ async function readLines(args) {
     if (endLine < startLine) {
       throw new Error("Invalid line range: end_line must be >= start_line.");
     }
-    const fileContent = await fs7.readFile(resolvedPath, "utf-8");
+    const fileContent = await fs8.readFile(resolvedPath, "utf-8");
     const lines = fileContent.split("\n");
     const total_lines = lines.length;
     const startIndex = startLine - 1;
@@ -14387,7 +14558,7 @@ async function readLines(args) {
 
 // src/app/agent/tools/CountLinesTool/CountLinesTool.ts
 import { createReadStream } from "fs";
-import { promises as fs8 } from "fs";
+import { promises as fs9 } from "fs";
 import readline from "readline";
 async function countLines(args) {
   const filepathInput = typeof args?.filepath === "string" && args.filepath.trim().length > 0 ? args.filepath : typeof args?.file_path === "string" ? args.file_path : "";
@@ -14414,7 +14585,7 @@ async function countLines(args) {
     };
   }
   try {
-    if (!(await fs8.stat(filepath)).isFile()) {
+    if (!(await fs9.stat(filepath)).isFile()) {
       throw new Error(`File '${filepath}' not found or is not a file.`);
     }
     const fileStream = createReadStream(filepath);
@@ -14604,7 +14775,7 @@ function formatTodoResult(result) {
 
 // src/app/agent/tools/FindByNameTool/FindByNameTool.ts
 init_sandbox_policy();
-import path9 from "path";
+import path10 from "path";
 import { promises as fsPromises } from "fs";
 import os7 from "os";
 var MAX_RESULTS = 100;
@@ -14628,7 +14799,7 @@ var DEFAULT_IGNORE2 = /* @__PURE__ */ new Set([
 ]);
 function expandTilde2(p) {
   if (p === "~") return os7.homedir();
-  if (p.startsWith("~/")) return path9.join(os7.homedir(), p.slice(2));
+  if (p.startsWith("~/")) return path10.join(os7.homedir(), p.slice(2));
   return p;
 }
 function globToRegex(glob) {
@@ -14672,7 +14843,7 @@ function shouldIgnore2(name, extraPatterns, includeHidden) {
 }
 function matchesExtensions(filename, extensions) {
   if (!extensions || extensions.length === 0) return true;
-  const ext = path9.extname(filename).toLowerCase();
+  const ext = path10.extname(filename).toLowerCase();
   return extensions.some((e) => {
     const norm = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
     return ext === norm;
@@ -14690,8 +14861,8 @@ async function searchDirectory(dir, pattern, baseDir, options, results) {
     if (results.length >= MAX_RESULTS) break;
     const { name } = entry;
     if (shouldIgnore2(name, options.excludePatterns, options.includeHidden)) continue;
-    const fullPath = path9.join(dir, name);
-    const relativePath = path9.relative(baseDir, fullPath).split(path9.sep).join("/");
+    const fullPath = path10.join(dir, name);
+    const relativePath = path10.relative(baseDir, fullPath).split(path10.sep).join("/");
     if (entry.isDirectory()) {
       if (pattern.test(name)) {
         results.push({ path: relativePath, type: "directory" });
@@ -14773,7 +14944,7 @@ async function findByName(args) {
 }
 
 // src/app/agent/tools/GrepSearchTool/GrepSearchTool.ts
-import path10 from "path";
+import path11 from "path";
 import { promises as fsPromises2 } from "fs";
 import os8 from "os";
 var MAX_RESULTS2 = 200;
@@ -14863,12 +15034,12 @@ var TEXT_BASENAMES = /* @__PURE__ */ new Set([
 ]);
 function expandTilde3(p) {
   if (p === "~") return os8.homedir();
-  if (p.startsWith("~/")) return path10.join(os8.homedir(), p.slice(2));
+  if (p.startsWith("~/")) return path11.join(os8.homedir(), p.slice(2));
   return p;
 }
 function isTextFile(filepath) {
-  const ext = path10.extname(filepath).toLowerCase();
-  const base = path10.basename(filepath);
+  const ext = path11.extname(filepath).toLowerCase();
+  const base = path11.basename(filepath);
   return TEXT_EXTENSIONS.has(ext) || TEXT_BASENAMES.has(base) || base.startsWith(".") && !ext;
 }
 function shouldIgnore3(name) {
@@ -14905,7 +15076,7 @@ async function searchFile(filepath, baseDir, pattern, contextLines, maxMatchesPe
     if (stat.size > MAX_FILE_SIZE) return null;
     const content = await fsPromises2.readFile(filepath, "utf-8");
     const lines = content.split("\n");
-    const relativePath = path10.relative(baseDir, filepath).split(path10.sep).join("/");
+    const relativePath = path11.relative(baseDir, filepath).split(path11.sep).join("/");
     const matches = [];
     for (let i = 0; i < lines.length && matches.length < maxMatchesPerFile; i++) {
       const line = lines[i];
@@ -14939,7 +15110,7 @@ async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextL
   for (const entry of entries) {
     if (stats.totalMatches >= maxResults) break;
     if (shouldIgnore3(entry.name)) continue;
-    const fullPath = path10.join(dir, entry.name);
+    const fullPath = path11.join(dir, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, maxResults, maxMatchesPerFile, results, stats);
     } else if (entry.isFile()) {
@@ -14980,7 +15151,7 @@ async function grepSearch(args) {
   });
   if (!query || typeof query !== "string") return empty("query is required");
   if (!searchPath) return empty("path is required");
-  const resolvedPath = path10.resolve(expandTilde3(searchPath));
+  const resolvedPath = path11.resolve(expandTilde3(searchPath));
   const stat = await fsPromises2.stat(resolvedPath).catch(() => null);
   if (!stat) return empty(`Path not found: ${resolvedPath}`);
   let pattern;
@@ -14996,7 +15167,7 @@ async function grepSearch(args) {
       await searchDirectory2(resolvedPath, resolvedPath, pattern, include_patterns, context_lines, max_results, max_matches_per_file, results, stats);
     } else if (stat.isFile()) {
       stats.filesSearched = 1;
-      const fileResult = await searchFile(resolvedPath, path10.dirname(resolvedPath), pattern, context_lines, max_matches_per_file);
+      const fileResult = await searchFile(resolvedPath, path11.dirname(resolvedPath), pattern, context_lines, max_matches_per_file);
       if (fileResult) {
         results.push(fileResult);
         stats.totalMatches = fileResult.match_count;
@@ -15019,7 +15190,7 @@ async function grepSearch(args) {
 }
 
 // src/app/agent/tools/ViewFileOutlineTool/ViewFileOutlineTool.ts
-import path11 from "path";
+import path12 from "path";
 import { promises as fsPromises3 } from "fs";
 var LANGUAGE_MAP = {
   ".ts": "typescript",
@@ -15133,7 +15304,7 @@ var PATTERNS = {
   ]
 };
 function detectLanguage(filepath) {
-  const ext = path11.extname(filepath).toLowerCase();
+  const ext = path12.extname(filepath).toLowerCase();
   return LANGUAGE_MAP[ext] || "unknown";
 }
 function determineItemType(line, language) {
@@ -15229,7 +15400,7 @@ async function viewFileOutline(args) {
         error: "file_path is required and must be a string"
       };
     }
-    const resolvedPath = path11.resolve(file_path);
+    const resolvedPath = path12.resolve(file_path);
     let content;
     try {
       content = await fsPromises3.readFile(resolvedPath, "utf-8");
@@ -15275,21 +15446,21 @@ init_CommandStatusTool();
 // src/app/agent/tools/TaskBoundaryTool/TaskBoundaryTool.ts
 init_sandbox_policy();
 init_task_store();
-import path12 from "path";
-import { promises as fs10 } from "fs";
+import path13 from "path";
+import { promises as fs11 } from "fs";
 var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
   const policy = getSandboxPolicy();
-  const baseDir = path12.join(policy.workspaceRoot, ".bluma", "artifacts");
+  const baseDir = path13.join(policy.workspaceRoot, ".bluma", "artifacts");
   const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
-  artifactsDir = path12.join(baseDir, sessionId);
-  await fs10.mkdir(artifactsDir, { recursive: true });
+  artifactsDir = path13.join(baseDir, sessionId);
+  await fs11.mkdir(artifactsDir, { recursive: true });
   return artifactsDir;
 }
 async function updateTaskFile(task) {
   const dir = await getArtifactsDir();
-  const taskFile = path12.join(dir, "task.md");
+  const taskFile = path13.join(dir, "task.md");
   const content = `# ${task.taskName}
 
         **Mode:** ${task.mode}  
@@ -15301,7 +15472,7 @@ async function updateTaskFile(task) {
         ## Summary
         ${task.summary}
         `;
-  await fs10.writeFile(taskFile, content, "utf-8");
+  await fs11.writeFile(taskFile, content, "utf-8");
 }
 async function taskBoundary(args) {
   try {
@@ -15417,8 +15588,8 @@ async function readArtifact(args) {
       return { success: false, error: "filename is required" };
     }
     const dir = await getArtifactsDir();
-    const filepath = path12.join(dir, filename);
-    const content = await fs10.readFile(filepath, "utf-8");
+    const filepath = path13.join(dir, filename);
+    const content = await fs11.readFile(filepath, "utf-8");
     return {
       success: true,
       content
@@ -15962,8 +16133,8 @@ ${skill.content}`;
 }
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryTool.ts
-import * as fs11 from "fs";
-import * as path13 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 import os10 from "os";
 var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
 var PROMPT_DEFAULT_MAX_NOTES = 25;
@@ -15972,14 +16143,14 @@ function readCodingMemoryForPrompt(options) {
   const maxTotal = options?.maxTotalChars ?? PROMPT_DEFAULT_MAX_TOTAL;
   const maxNotes = options?.maxNotes ?? PROMPT_DEFAULT_MAX_NOTES;
   const preview = options?.previewCharsPerNote ?? PROMPT_DEFAULT_PREVIEW;
-  const globalPath = path13.join(os10.homedir(), ".bluma", "coding_memory.json");
-  const legacyPath = path13.join(process.cwd(), ".bluma", "coding_memory.json");
+  const globalPath = path14.join(os10.homedir(), ".bluma", "coding_memory.json");
+  const legacyPath = path14.join(process.cwd(), ".bluma", "coding_memory.json");
   let raw = null;
   try {
-    if (fs11.existsSync(globalPath)) {
-      raw = fs11.readFileSync(globalPath, "utf-8");
-    } else if (path13.resolve(globalPath) !== path13.resolve(legacyPath) && fs11.existsSync(legacyPath)) {
-      raw = fs11.readFileSync(legacyPath, "utf-8");
+    if (fs12.existsSync(globalPath)) {
+      raw = fs12.readFileSync(globalPath, "utf-8");
+    } else if (path14.resolve(globalPath) !== path14.resolve(legacyPath) && fs12.existsSync(legacyPath)) {
+      raw = fs12.readFileSync(legacyPath, "utf-8");
     }
   } catch {
     return "";
@@ -16017,10 +16188,10 @@ var memoryStore = [];
 var nextId = 1;
 var loaded = false;
 function getMemoryFilePath() {
-  return path13.join(os10.homedir(), ".bluma", "coding_memory.json");
+  return path14.join(os10.homedir(), ".bluma", "coding_memory.json");
 }
 function getLegacyMemoryFilePath() {
-  return path13.join(process.cwd(), ".bluma", "coding_memory.json");
+  return path14.join(process.cwd(), ".bluma", "coding_memory.json");
 }
 function loadMemoryFromFile() {
   if (loaded) return;
@@ -16030,19 +16201,19 @@ function loadMemoryFromFile() {
   try {
     const filePath = getMemoryFilePath();
     const legacy = getLegacyMemoryFilePath();
-    const legacyDistinct = path13.resolve(legacy) !== path13.resolve(filePath);
+    const legacyDistinct = path14.resolve(legacy) !== path14.resolve(filePath);
     const readIntoStore = (p) => {
-      const raw = fs11.readFileSync(p, "utf-8");
+      const raw = fs12.readFileSync(p, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.entries)) {
         memoryStore = parsed.entries;
         nextId = typeof parsed.nextId === "number" ? parsed.nextId : memoryStore.length + 1;
       }
     };
-    if (fs11.existsSync(filePath)) {
+    if (fs12.existsSync(filePath)) {
       readIntoStore(filePath);
     }
-    if (memoryStore.length === 0 && legacyDistinct && fs11.existsSync(legacy)) {
+    if (memoryStore.length === 0 && legacyDistinct && fs12.existsSync(legacy)) {
       readIntoStore(legacy);
       if (memoryStore.length > 0) {
         saveMemoryToFile();
@@ -16056,16 +16227,16 @@ function loadMemoryFromFile() {
 function saveMemoryToFile() {
   try {
     const filePath = getMemoryFilePath();
-    const dir = path13.dirname(filePath);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    const dir = path14.dirname(filePath);
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
     const payload = {
       entries: memoryStore,
       nextId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs11.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+    fs12.writeFileSync(filePath, JSON.stringify(payload, null, 2));
   } catch {
   }
 }
@@ -16567,7 +16738,7 @@ async function cronDelete(args) {
 
 // src/app/agent/tools/NotebookEditTool/NotebookEditTool.ts
 init_sandbox_policy();
-import { promises as fs12 } from "fs";
+import { promises as fs13 } from "fs";
 function sourceToString(s) {
   if (s == null) return "";
   return Array.isArray(s) ? s.join("") : s;
@@ -16579,7 +16750,7 @@ function stringToSource(s) {
 async function applyNotebookOperation(filepath, op) {
   try {
     const resolved = resolveWorkspacePath(filepath);
-    const raw = await fs12.readFile(resolved, "utf-8");
+    const raw = await fs13.readFile(resolved, "utf-8");
     let doc;
     try {
       doc = JSON.parse(raw);
@@ -16620,7 +16791,7 @@ async function applyNotebookOperation(filepath, op) {
         return JSON.stringify({ success: false, error: `cell_index out of range: ${i}` });
       }
       doc.cells[i].source = stringToSource(String(op.source ?? ""));
-      await fs12.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
+      await fs13.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
       return JSON.stringify({ success: true, message: `Updated cell ${i}` });
     }
     if (op.operation === "append_markdown_cell") {
@@ -16629,7 +16800,7 @@ async function applyNotebookOperation(filepath, op) {
         source: stringToSource(String(op.source ?? "")),
         metadata: {}
       });
-      await fs12.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
+      await fs13.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
       return JSON.stringify({ success: true, message: `Appended markdown cell at index ${doc.cells.length - 1}` });
     }
     if (op.operation === "delete_cell") {
@@ -16638,7 +16809,7 @@ async function applyNotebookOperation(filepath, op) {
         return JSON.stringify({ success: false, error: `cell_index out of range: ${i}` });
       }
       doc.cells.splice(i, 1);
-      await fs12.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
+      await fs13.writeFile(resolved, JSON.stringify(doc, null, 2), "utf-8");
       return JSON.stringify({ success: true, message: `Deleted cell ${i}` });
     }
     return JSON.stringify({ success: false, error: "unknown operation" });
@@ -16677,8 +16848,8 @@ async function notebook_edit(args) {
 // src/app/agent/tools/LspQueryTool/LspQueryTool.ts
 init_sandbox_policy();
 import { spawn as spawn2 } from "child_process";
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 import { pathToFileURL } from "url";
 var RpcBuffer = class {
   buf = Buffer.alloc(0);
@@ -16728,12 +16899,12 @@ async function lsp_query(args) {
   } catch (e) {
     return JSON.stringify({ success: false, error: e.message || String(e) });
   }
-  if (!fs13.existsSync(resolved) || !fs13.statSync(resolved).isFile()) {
+  if (!fs14.existsSync(resolved) || !fs14.statSync(resolved).isFile()) {
     return JSON.stringify({ success: false, error: "file not found" });
   }
-  const content = fs13.readFileSync(resolved, "utf-8");
+  const content = fs14.readFileSync(resolved, "utf-8");
   const uri = pathToFileURL(resolved).href;
-  const root = path14.dirname(resolved);
+  const root = path15.dirname(resolved);
   const line0 = Math.max(0, Math.floor(Number(args.line) || 1) - 1);
   const character = Math.max(0, Math.floor(Number(args.character ?? 0)));
   const operation = args.operation === "references" ? "references" : "definition";
@@ -16853,8 +17024,8 @@ async function lsp_query(args) {
 
 // src/app/agent/tools/FileWriteTool/FileWriteTool.ts
 init_sandbox_policy();
-import { promises as fs14 } from "fs";
-import path15 from "path";
+import { promises as fs15 } from "fs";
+import path16 from "path";
 async function fileWrite(args) {
   const {
     filepath,
@@ -16872,10 +17043,10 @@ async function fileWrite(args) {
       return { success: false, error: "content is required" };
     }
     const resolvedPath = resolveWorkspacePath(targetPath);
-    const dir = path15.dirname(resolvedPath);
+    const dir = path16.dirname(resolvedPath);
     let existed = false;
     try {
-      const st = await fs14.stat(resolvedPath);
+      const st = await fs15.stat(resolvedPath);
       existed = st.isFile();
     } catch {
       existed = false;
@@ -16889,15 +17060,15 @@ async function fileWrite(args) {
     let previousContent = "";
     if (existed) {
       try {
-        previousContent = await fs14.readFile(resolvedPath, "utf-8");
+        previousContent = await fs15.readFile(resolvedPath, "utf-8");
       } catch {
         previousContent = "";
       }
     }
     if (create_directories) {
-      await fs14.mkdir(dir, { recursive: true });
+      await fs15.mkdir(dir, { recursive: true });
     }
-    await fs14.writeFile(resolvedPath, String(content), "utf-8");
+    await fs15.writeFile(resolvedPath, String(content), "utf-8");
     const bytes = Buffer.byteLength(String(content), "utf-8");
     return {
       success: true,
@@ -17206,9 +17377,9 @@ async function signalMailbox(args) {
 }
 
 // src/app/agent/tools/ReplTool/ReplTool.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import os15 from "os";
-import path20 from "path";
+import path21 from "path";
 import { exec } from "child_process";
 import { v4 as uuidv47 } from "uuid";
 import { promisify } from "util";
@@ -17220,20 +17391,20 @@ async function repl(params) {
   let tempFile;
   switch (language) {
     case "python": {
-      tempFile = path20.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.py`);
-      fs19.writeFileSync(tempFile, code, "utf-8");
+      tempFile = path21.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.py`);
+      fs20.writeFileSync(tempFile, code, "utf-8");
       command = `python3 "${tempFile}"`;
       break;
     }
     case "node": {
-      tempFile = path20.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.mjs`);
-      fs19.writeFileSync(tempFile, code, "utf-8");
+      tempFile = path21.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.mjs`);
+      fs20.writeFileSync(tempFile, code, "utf-8");
       command = `node "${tempFile}"`;
       break;
     }
     case "bash": {
-      tempFile = path20.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.sh`);
-      fs19.writeFileSync(tempFile, `#!/bin/bash
+      tempFile = path21.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.sh`);
+      fs20.writeFileSync(tempFile, `#!/bin/bash
 set -e
 ${code}`, "utf-8");
       command = `bash "${tempFile}"`;
@@ -17247,7 +17418,7 @@ ${code}`, "utf-8");
       // 5MB
     });
     try {
-      fs19.unlinkSync(tempFile);
+      fs20.unlinkSync(tempFile);
     } catch {
     }
     return {
@@ -17259,7 +17430,7 @@ ${code}`, "utf-8");
     };
   } catch (error) {
     try {
-      fs19.unlinkSync(tempFile);
+      fs20.unlinkSync(tempFile);
     } catch {
     }
     const exitCode = error.code === "ERR_CHILD_PROCESS_TIMEOUT" ? 124 : error.status ?? 1;
@@ -17381,6 +17552,24 @@ function countToolDefinitionsTokens(tools) {
   const json = JSON.stringify(tools);
   return enc.encode(json).length;
 }
+var DEFAULT_OUTPUT_TOKEN_RESERVE = 8192;
+var DEFAULT_PROTOCOL_OVERHEAD_TOKENS = 512;
+function computeEffectiveInputBudget(rawBudget, toolDefinitions = [], options) {
+  const toolDefinitionsTokens = countToolDefinitionsTokens(toolDefinitions);
+  const outputReserveTokens = options?.outputReserveTokens ?? DEFAULT_OUTPUT_TOKEN_RESERVE;
+  const protocolOverheadTokens = options?.protocolOverheadTokens ?? DEFAULT_PROTOCOL_OVERHEAD_TOKENS;
+  const effectiveBudget = Math.max(
+    0,
+    rawBudget - toolDefinitionsTokens - outputReserveTokens - protocolOverheadTokens
+  );
+  return {
+    rawBudget,
+    toolDefinitionsTokens,
+    outputReserveTokens,
+    protocolOverheadTokens,
+    effectiveBudget
+  };
+}
 
 // src/app/agent/tools/CtxInspectTool/CtxInspectTool.ts
 async function ctx_inspect(args = {}) {
@@ -17607,8 +17796,8 @@ ${preview}${toRemove.length > 5 ? `
 
 // src/app/agent/tools/BriefTool/BriefTool.ts
 init_sandbox_policy();
-import * as fs20 from "fs";
-import * as path21 from "path";
+import * as fs21 from "fs";
+import * as path22 from "path";
 async function brief(args) {
   const sentAt = (/* @__PURE__ */ new Date()).toISOString();
   if (!args.message || !args.message.trim()) {
@@ -17627,9 +17816,9 @@ async function brief(args) {
     const resolved = [];
     for (const filePath of args.attachments) {
       try {
-        const absolutePath = path21.isAbsolute(filePath) ? filePath : path21.join(resolveWorkspacePath("."), filePath);
-        if (fs20.existsSync(absolutePath)) {
-          const stat = fs20.statSync(absolutePath);
+        const absolutePath = path22.isAbsolute(filePath) ? filePath : path22.join(resolveWorkspacePath("."), filePath);
+        if (fs21.existsSync(absolutePath)) {
+          const stat = fs21.statSync(absolutePath);
           resolved.push({
             path: absolutePath,
             size: stat.size,
@@ -17668,14 +17857,14 @@ async function brief(args) {
 }
 
 // src/app/agent/tools/DreamEngineTool/DreamEngineTool.ts
-import * as fs21 from "fs";
-import * as path22 from "path";
+import * as fs22 from "fs";
+import * as path23 from "path";
 import os16 from "os";
 function memoryPath() {
-  return path22.join(process.env.HOME || os16.homedir(), ".bluma", "coding_memory.json");
+  return path23.join(process.env.HOME || os16.homedir(), ".bluma", "coding_memory.json");
 }
 function sessionsDir() {
-  return path22.join(process.env.HOME || os16.homedir(), ".bluma", "sessions");
+  return path23.join(process.env.HOME || os16.homedir(), ".bluma", "sessions");
 }
 function normalizeNote(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -17700,9 +17889,9 @@ async function dream(args = {}) {
   const mergeSimilar = args.mergeSimilar !== false;
   const memPath = memoryPath();
   let memData = null;
-  if (fs21.existsSync(memPath)) {
+  if (fs22.existsSync(memPath)) {
     try {
-      memData = JSON.parse(fs21.readFileSync(memPath, "utf-8"));
+      memData = JSON.parse(fs22.readFileSync(memPath, "utf-8"));
     } catch {
     }
   }
@@ -17779,12 +17968,12 @@ async function dream(args = {}) {
     pruned += removed.length;
   }
   const sessDir = sessionsDir();
-  if (fs21.existsSync(sessDir)) {
+  if (fs22.existsSync(sessDir)) {
     try {
-      const sessionFiles = fs21.readdirSync(sessDir).filter((f) => f.endsWith(".json")).slice(-5);
+      const sessionFiles = fs22.readdirSync(sessDir).filter((f) => f.endsWith(".json")).slice(-5);
       for (const sf of sessionFiles) {
         try {
-          const sessionData = JSON.parse(fs21.readFileSync(path22.join(sessDir, sf), "utf-8"));
+          const sessionData = JSON.parse(fs22.readFileSync(path23.join(sessDir, sf), "utf-8"));
           if (sessionData?.summary) {
             consolidatedMemories.push(`Session ${sf}: ${sessionData.summary}`);
           }
@@ -17799,7 +17988,7 @@ async function dream(args = {}) {
     memData.nextId = entries.reduce((max, e) => Math.max(max, e.id || 0), 0) + 1;
     memData.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     try {
-      fs21.writeFileSync(memPath, JSON.stringify(memData, null, 2), "utf-8");
+      fs22.writeFileSync(memPath, JSON.stringify(memData, null, 2), "utf-8");
     } catch (e) {
       return {
         success: false,
@@ -17992,8 +18181,8 @@ async function context_collapse(args = {}) {
 
 // src/app/agent/tools/CreateNextAppTool/CreateNextAppTool.ts
 init_sandbox_policy();
-import { promises as fs22 } from "fs";
-import path23 from "path";
+import { promises as fs23 } from "fs";
+import path24 from "path";
 
 // src/app/agent/tools/ShellCommandTool/ShellCommandTool.ts
 init_sandbox_policy();
@@ -18422,6 +18611,40 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
+`,
+  // App Router mínimo (obrigatório para next build / deploy no Severino)
+  "app/layout.tsx": `import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: '{{NAME}}',
+  description: 'Generated by create-next-app',
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`,
+  "app/page.tsx": `export default function Home() {
+  return (
+    <main className="flex min-h-screen flex-col items-center justify-center p-8">
+      <h1 className="text-2xl font-semibold">{{NAME}}</h1>
+      <p className="mt-2 text-sm text-gray-600">Next.js app ready for deploy.</p>
+    </main>
+  );
+}
+`,
+  "app/globals.css": `@tailwind base;
+@tailwind components;
+@tailwind utilities;
 `
 };
 var FULL_FILES = {
@@ -18566,25 +18789,22 @@ body {
   }
 }
 `,
-  // shadcn/ui base components
+  // shadcn/ui base components (sem @radix-ui/react-slot — evita falha de build no deploy)
   "components/ui/button.tsx": `import * as React from "react"
 import { cva, type VariantProps } from "class-variance-authority"
 import { cn } from "@/lib/utils"
 
 const buttonVariants = cva(
-  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-zinc-400 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
   {
     variants: {
       variant: {
-        default: "bg-primary text-primary-foreground hover:bg-primary/90",
-        destructive:
-          "bg-destructive text-destructive-foreground hover:bg-destructive/90",
-        outline:
-          "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
-        secondary:
-          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
-        ghost: "hover:bg-accent hover:text-accent-foreground",
-        link: "text-primary underline-offset-4 hover:underline",
+        default: "bg-zinc-900 text-white hover:bg-zinc-800",
+        destructive: "bg-red-600 text-white hover:bg-red-700",
+        outline: "border border-zinc-200 bg-white hover:bg-zinc-50",
+        secondary: "bg-zinc-100 text-zinc-900 hover:bg-zinc-200",
+        ghost: "hover:bg-zinc-100",
+        link: "text-zinc-900 underline-offset-4 hover:underline",
       },
       size: {
         default: "h-10 px-4 py-2",
@@ -18602,21 +18822,16 @@ const buttonVariants = cva(
 
 export interface ButtonProps
   extends React.ButtonHTMLAttributes<HTMLButtonElement>,
-    VariantProps<typeof buttonVariants> {
-  asChild?: boolean
-}
+    VariantProps<typeof buttonVariants> {}
 
 const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
-  ({ className, variant, size, asChild = false, ...props }, ref) => {
-    const Comp = asChild ? Slot : "button"
-    return (
-      <Comp
-        className={cn(buttonVariants({ variant, size, className }))}
-        ref={ref}
-        {...props}
-      />
-    )
-  }
+  ({ className, variant, size, ...props }, ref) => (
+    <button
+      className={cn(buttonVariants({ variant, size, className }))}
+      ref={ref}
+      {...props}
+    />
+  )
 )
 Button.displayName = "Button"
 
@@ -18632,7 +18847,7 @@ const Card = React.forwardRef<
   <div
     ref={ref}
     className={cn(
-      "rounded-lg border bg-card text-card-foreground shadow-sm",
+      "rounded-lg border border-zinc-200 bg-white text-zinc-950 shadow-sm",
       className
     )}
     {...props}
@@ -18673,7 +18888,7 @@ const CardDescription = React.forwardRef<
 >(({ className, ...props }, ref) => (
   <p
     ref={ref}
-    className={cn("text-sm text-muted-foreground", className)}
+    className={cn("text-sm text-zinc-500", className)}
     {...props}
   />
 ))
@@ -18713,7 +18928,7 @@ const Input = React.forwardRef<HTMLInputElement, InputProps>(
       <input
         type={type}
         className={cn(
-          "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+          "flex h-10 w-full rounded-md border border-zinc-200 bg-white px-3 py-2 text-sm file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-zinc-400 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-zinc-400 focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
           className
         )}
         ref={ref}
@@ -18767,10 +18982,10 @@ export function cn(...inputs: ClassValue[]) {
 `
 };
 async function createFile(filePath, content, projectName) {
-  const dir = path23.dirname(filePath);
-  await fs22.mkdir(dir, { recursive: true });
+  const dir = path24.dirname(filePath);
+  await fs23.mkdir(dir, { recursive: true });
   const replacedContent = content.replace(/{{NAME}}/g, projectName);
-  await fs22.writeFile(filePath, replacedContent, "utf-8");
+  await fs23.writeFile(filePath, replacedContent, "utf-8");
 }
 async function createNextApp(args) {
   const {
@@ -18789,26 +19004,26 @@ async function createNextApp(args) {
       };
     }
     const baseDir = directory ? resolveWorkspacePath(directory) : resolveWorkspacePath(".");
-    const projectPath = path23.join(baseDir, name);
+    const projectPath = path24.join(baseDir, name);
     try {
-      await fs22.access(projectPath);
+      await fs23.access(projectPath);
       return {
         success: false,
         error: `Directory already exists: ${projectPath}. Remove it first or choose a different name.`
       };
     } catch {
     }
-    await fs22.mkdir(projectPath, { recursive: true });
+    await fs23.mkdir(projectPath, { recursive: true });
     const filesToCreate = template === "minimal" ? MINIMAL_FILES : FULL_FILES;
     const filesCreated = [];
     for (const [relativePath, content] of Object.entries(filesToCreate)) {
       if (relativePath === "package.json.full") continue;
-      const fullPath = path23.join(projectPath, relativePath);
+      const fullPath = path24.join(projectPath, relativePath);
       await createFile(fullPath, content, name);
       filesCreated.push(relativePath);
     }
     if (template === "full") {
-      const packageJsonPath = path23.join(projectPath, "package.json");
+      const packageJsonPath = path24.join(projectPath, "package.json");
       const fullPackageJson = FULL_FILES["package.json.full"];
       if (fullPackageJson) {
         await createFile(packageJsonPath, fullPackageJson, name);
@@ -18850,8 +19065,11 @@ async function createNextApp(args) {
 
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 init_sandbox_policy();
-import { promises as fs23 } from "fs";
-import path24 from "path";
+import { promises as fs24 } from "fs";
+import path25 from "path";
+function shQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
 var EXCLUDE_PATTERNS = [
   "node_modules",
   ".next",
@@ -18867,12 +19085,15 @@ var EXCLUDE_PATTERNS = [
   ".vercel",
   ".turbo"
 ];
-async function createProjectZip(projectDir, zipPath) {
-  const excludes = [];
-  for (const pattern of EXCLUDE_PATTERNS) {
-    excludes.push("--exclude", pattern);
+function zipExcludeArg(pattern) {
+  if (pattern.includes("*") || pattern.startsWith(".")) {
+    return pattern;
   }
-  const zipCommand = `zip -r "${zipPath}" . ${excludes.join(" ")}`;
+  return `${pattern}/*`;
+}
+async function createProjectZip(projectDir, zipPath) {
+  const excludeFlags = EXCLUDE_PATTERNS.flatMap((pattern) => ["-x", zipExcludeArg(pattern)]);
+  const zipCommand = ["zip", "-r", shQuote(zipPath), ".", ...excludeFlags.map(shQuote)].join(" ");
   const result = await shellCommand({
     command: zipCommand,
     cwd: projectDir,
@@ -18888,6 +19109,7 @@ async function createProjectZip(projectDir, zipPath) {
 async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
   const deployUrl = `${severinoUrl.replace(/\/$/, "")}/api/v1/deploy`;
   const curlArgs = [
+    "-sS",
     "-X",
     "POST",
     deployUrl,
@@ -18905,7 +19127,7 @@ async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
     curlArgs.push("-H", `X-API-Key: ${apiKey}`);
   }
   curlArgs.push("-H", "Accept: application/json");
-  const curlCommand = `curl ${curlArgs.join(" ")}`;
+  const curlCommand = `curl ${curlArgs.map(shQuote).join(" ")}`;
   const result = await shellCommand({
     command: curlCommand,
     timeout: 60
@@ -18992,8 +19214,10 @@ function buildFactorAiManifest(appContext, deployResult, appName) {
       mode: "tool-first",
       instructions: [
         "Read factorai.sh.json as the source of truth before editing files.",
-        "Prefer incremental changes and preserve the existing deployment context.",
-        "After edits, use the redeploy tool instead of rebuilding from scratch."
+        "Load skill factorai-sh for the full FactorAI.sh workflow.",
+        "For an app already online: use factorai.sh.apply_app_changes with deploy:true (not deploy_app again).",
+        "Poll factorai.sh.get_app_status until building\u2192ready before reporting the live URL.",
+        "Use factorai.sh.redeploy_app only when rebuilding without new file patches."
       ]
     },
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -19001,8 +19225,8 @@ function buildFactorAiManifest(appContext, deployResult, appName) {
 }
 async function writeFactorAiManifest(projectDir, appContext, deployResult, appName) {
   const manifest = buildFactorAiManifest(appContext, deployResult, appName);
-  const manifestPath = path24.join(projectDir, "factorai.sh.json");
-  await fs23.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = path25.join(projectDir, "factorai.sh.json");
+  await fs24.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   return manifest;
 }
@@ -19022,23 +19246,23 @@ async function deployApp(args) {
     }
     const resolvedProjectDir = resolveWorkspacePath(projectDir);
     try {
-      await fs23.access(resolvedProjectDir);
+      await fs24.access(resolvedProjectDir);
     } catch {
       return {
         success: false,
         error: `Project directory not found: ${resolvedProjectDir}`
       };
     }
-    const packageJsonPath = path24.join(resolvedProjectDir, "package.json");
+    const packageJsonPath = path25.join(resolvedProjectDir, "package.json");
     try {
-      await fs23.access(packageJsonPath);
+      await fs24.access(packageJsonPath);
     } catch {
       return {
         success: false,
         error: "Not a Next.js project: package.json not found"
       };
     }
-    const packageJsonContent = await fs23.readFile(packageJsonPath, "utf-8");
+    const packageJsonContent = await fs24.readFile(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     const hasNext = packageJson.dependencies?.next || packageJson.devDependencies?.next;
     if (!hasNext) {
@@ -19047,18 +19271,18 @@ async function deployApp(args) {
         error: "Not a Next.js project: next not found in dependencies"
       };
     }
-    const appName = name || packageJson.name || path24.basename(resolvedProjectDir);
-    const tempDir = path24.join(resolvedProjectDir, ".tmp");
-    await fs23.mkdir(tempDir, { recursive: true });
-    const zipPath = path24.join(tempDir, `${appName}-${Date.now()}.zip`);
+    const appName = name || packageJson.name || path25.basename(resolvedProjectDir);
+    const tempDir = path25.join(resolvedProjectDir, ".tmp");
+    await fs24.mkdir(tempDir, { recursive: true });
+    const zipPath = path25.join(tempDir, `${appName}-${Date.now()}.zip`);
     console.log(`[deploy-app] Creating ZIP: ${zipPath}`);
     await createProjectZip(resolvedProjectDir, zipPath);
-    const zipStats = await fs23.stat(zipPath);
+    const zipStats = await fs24.stat(zipPath);
     const zipSizeMB = zipStats.size / 1024 / 1024;
     if (zipSizeMB > 50) {
-      await fs23.unlink(zipPath).catch(() => {
+      await fs24.unlink(zipPath).catch(() => {
       });
-      await fs23.rmdir(tempDir).catch(() => {
+      await fs24.rmdir(tempDir).catch(() => {
       });
       return {
         success: false,
@@ -19069,8 +19293,8 @@ async function deployApp(args) {
     console.log(`[deploy-app] Uploading to ${severinoUrl}...`);
     const deployResult = await uploadToSeverino(zipPath, severinoUrl, appName, apiKey, appId);
     try {
-      await fs23.unlink(zipPath);
-      await fs23.rmdir(tempDir);
+      await fs24.unlink(zipPath);
+      await fs24.rmdir(tempDir);
     } catch (e) {
       console.warn("[deploy-app] Cleanup warning:", e);
     }
@@ -19083,7 +19307,7 @@ async function deployApp(args) {
           appName
         );
         deployResult.factoraiManifest = manifest;
-        deployResult.factoraiManifestPath = path24.join(resolvedProjectDir, "factorai.sh.json");
+        deployResult.factoraiManifestPath = path25.join(resolvedProjectDir, "factorai.sh.json");
       }
       console.log(`[deploy-app] Deploy iniciado: ${deployResult.appId}`);
     }
@@ -19097,147 +19321,6 @@ async function deployApp(args) {
   }
 }
 
-// src/app/agent/runtime/factorai_context.ts
-import fs24 from "fs";
-import path25 from "path";
-function normalizeContext(raw) {
-  if (!raw || typeof raw.appId !== "string" || !raw.appId.trim()) {
-    return null;
-  }
-  const appId = raw.appId.trim();
-  return {
-    appId,
-    tenantId: typeof raw.tenantId === "string" ? raw.tenantId : null,
-    projectId: typeof raw.projectId === "string" ? raw.projectId : null,
-    workspaceId: typeof raw.workspaceId === "string" ? raw.workspaceId : null,
-    revisionId: typeof raw.revisionId === "string" ? raw.revisionId : null,
-    deploymentId: typeof raw.deploymentId === "string" ? raw.deploymentId : null,
-    buildJobId: typeof raw.buildJobId === "string" ? raw.buildJobId : null,
-    manifestPath: typeof raw.manifestPath === "string" ? raw.manifestPath : null,
-    manifestFile: typeof raw.manifestFile === "string" ? raw.manifestFile : null,
-    appUrl: typeof raw.appUrl === "string" ? raw.appUrl : null
-  };
-}
-function readJsonFile(filePath) {
-  try {
-    if (!fs24.existsSync(filePath)) {
-      return null;
-    }
-    const parsed = JSON.parse(fs24.readFileSync(filePath, "utf8"));
-    if (parsed && typeof parsed === "object") {
-      return parsed.appContext && typeof parsed.appContext === "object" ? parsed.appContext : parsed;
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-function readFactorAiWorkspaceManifest(projectDir = process.cwd()) {
-  const manifestPath = path25.join(projectDir, "factorai.sh.json");
-  try {
-    if (!fs24.existsSync(manifestPath)) {
-      return null;
-    }
-    const parsed = JSON.parse(fs24.readFileSync(manifestPath, "utf8"));
-    return parsed && typeof parsed === "object" ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function readContextFromWorkspace() {
-  const candidate = path25.join(process.cwd(), "factorai.sh.json");
-  const parsed = readJsonFile(candidate);
-  if (!parsed) {
-    return null;
-  }
-  const context = normalizeContext(parsed);
-  return context;
-}
-function loadFactorAiAppContext() {
-  return readContextFromWorkspace();
-}
-function formatFactorAiAppContextSummary(context) {
-  if (!context) {
-    return "";
-  }
-  const parts = [
-    `appId=${context.appId}`,
-    context.tenantId ? `tenantId=${context.tenantId}` : null,
-    context.projectId ? `projectId=${context.projectId}` : null,
-    context.workspaceId ? `workspaceId=${context.workspaceId}` : null,
-    context.revisionId ? `revisionId=${context.revisionId}` : null,
-    context.deploymentId ? `deploymentId=${context.deploymentId}` : null,
-    context.buildJobId ? `buildJobId=${context.buildJobId}` : null,
-    context.appUrl ? `appUrl=${context.appUrl}` : null
-  ].filter(Boolean);
-  return parts.join(" | ");
-}
-function buildFactorAiWorkspaceManifest(input) {
-  const projectDir = input.projectDir || process.cwd();
-  const existing = readFactorAiWorkspaceManifest(projectDir) || {};
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const nextAppContext = {
-    ...typeof existing.appContext === "object" && existing.appContext ? existing.appContext : {},
-    appId: input.appContext.appId,
-    tenantId: input.appContext.tenantId ?? null,
-    projectId: input.appContext.projectId ?? null,
-    workspaceId: input.appContext.workspaceId ?? null,
-    revisionId: input.appContext.revisionId ?? null,
-    deploymentId: input.appContext.deploymentId ?? null,
-    buildJobId: input.appContext.buildJobId ?? null,
-    manifestPath: "factorai.sh.json",
-    manifestFile: "factorai.sh.json",
-    appUrl: input.appContext.appUrl ?? null
-  };
-  return {
-    ...existing,
-    version: 1,
-    manifestFile: "factorai.sh.json",
-    manifestPath: "factorai.sh.json",
-    appContext: nextAppContext,
-    app: {
-      ...typeof existing.app === "object" && existing.app ? existing.app : {},
-      name: input.name ?? (typeof existing.app === "object" && existing.app ? existing.app.name : void 0) ?? null,
-      status: input.status ?? (typeof existing.app === "object" && existing.app ? existing.app.status : void 0) ?? "building",
-      isRedeploy: input.isRedeploy ?? (typeof existing.app === "object" && existing.app ? existing.app.isRedeploy : false),
-      message: input.message ?? (typeof existing.app === "object" && existing.app ? existing.app.message : null),
-      ...input.app || {}
-    },
-    agent: {
-      provider: "bluma",
-      mode: "tool-first",
-      instructions: [
-        "Read factorai.sh.json as the source of truth before editing files.",
-        "Prefer incremental changes and preserve the existing deployment context.",
-        "After edits, use the redeploy tool instead of rebuilding from scratch."
-      ],
-      ...typeof existing.agent === "object" && existing.agent ? existing.agent : {},
-      ...input.agent || {}
-    },
-    sandbox: {
-      ...typeof existing.sandbox === "object" && existing.sandbox ? existing.sandbox : {},
-      ...input.sandbox || {}
-    },
-    source: {
-      root: ".",
-      publicDir: "./public",
-      appDir: ".",
-      ...typeof existing.source === "object" && existing.source ? existing.source : {},
-      ...input.source || {}
-    },
-    updatedAt: now2,
-    ...input.extra || {}
-  };
-}
-async function writeFactorAiWorkspaceManifest(input) {
-  const projectDir = input.projectDir || process.cwd();
-  const manifest = buildFactorAiWorkspaceManifest({ ...input, projectDir });
-  const manifestPath = path25.join(projectDir, "factorai.sh.json");
-  fs24.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-  return { manifestPath, manifest };
-}
-
 // src/app/agent/runtime/native_tool_catalog.ts
 init_sandbox_policy();
 function getFactorAiBaseUrl() {
@@ -19389,7 +19472,7 @@ function getFactorAiSandboxToolDefinitions() {
       type: "function",
       function: {
         name: "factorai.sh.deploy_app",
-        description: "Deploy a Next.js project from the sandbox to the FactorAI hosting backend. The returned metadata must be written into factorai.sh.json in the project root for future incremental edits.",
+        description: "First deploy only: ZIP project source (excludes node_modules/.next) to SEVERINO_URL /api/v1/deploy. Writes factorai.sh.json. For later edits use apply_app_changes instead.",
         parameters: {
           type: "object",
           properties: {
@@ -19407,7 +19490,7 @@ function getFactorAiSandboxToolDefinitions() {
       type: "function",
       function: {
         name: "factorai.sh.get_app_status",
-        description: "Get the current status and contract for a FactorAI deployment in the sandbox.",
+        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.",
         parameters: {
           type: "object",
           properties: {
@@ -19422,7 +19505,7 @@ function getFactorAiSandboxToolDefinitions() {
       type: "function",
       function: {
         name: "factorai.sh.apply_app_changes",
-        description: "Apply incremental file changes to a FactorAI workspace and optionally redeploy.",
+        description: "Patch files on an already-deployed FactorAI app in THIS session only (read appId from factorai.sh.json in cwd). Each files[].content must be the COMPLETE file body (server replaces the whole file \u2014 never send a JSX/footer fragment). After edit_tool, read_file_lines the full file before calling. deploy:true (default) runs next build + restart. Prefer over deploy_app for live edits.",
         parameters: {
           type: "object",
           properties: {
@@ -20086,7 +20169,7 @@ var NATIVE_TOOL_ENTRIES = [
       autoApproveInLocal: false,
       autoApproveInSandbox: true,
       sandboxOnly: true,
-      description: "Sandbox-only FactorAI tool. Apply file changes to a deployed app workspace and redeploy it."
+      description: "This session only: appId from factorai.sh.json in cwd. Each files[].content = COMPLETE file (server replaces whole file). Read full file after edit_tool. deploy defaults true. Poll get_app_status until ready."
     },
     implementation: factorAiApplyAppChanges
   },
@@ -20145,7 +20228,7 @@ var SANDBOX_COMMUNICATION_TOOL_DEFINITIONS = [
     type: "function",
     function: {
       name: "message",
-      description: 'Deliver user-visible output. message_type "info": progress (does not end turn). message_type "result": ends turn; file deliverables MUST use attachments[] with paths under .bluma/artifacts/.',
+      description: 'Deliver user-visible output. message_type "info": progress (does not end turn). message_type "result": ends turn; file deliverables use attachments[] under .bluma/artifacts/; live FactorAI.sh app URL MUST use factor-sh-url-app (auto-filled from factorai.sh.json when omitted).',
       parameters: {
         type: "object",
         properties: {
@@ -20159,6 +20242,10 @@ var SANDBOX_COMMUNICATION_TOOL_DEFINITIONS = [
             type: "array",
             items: { type: "string" },
             description: "Workspace file paths under .bluma/artifacts/ (required for file deliverables on result)."
+          },
+          "factor-sh-url-app": {
+            type: "string",
+            description: "Required on message_type result after FactorAI.sh deploy/redeploy: absolute live app URL for Severino (from factorai.sh.json appUrl). Auto-filled if omitted."
           }
         },
         required: ["content", "message_type"],
@@ -20628,17 +20715,17 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path41 from "path";
-import fs38 from "fs";
+import path43 from "path";
+import fs40 from "fs";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path30 from "path";
-import { promises as fs28 } from "fs";
+import path31 from "path";
+import { promises as fs29 } from "fs";
 
 // src/app/agent/session_manager/agent_session_paths.ts
-import path29 from "path";
-import { promises as fs27 } from "fs";
+import path30 from "path";
+import { promises as fs28 } from "fs";
 
 // src/app/agent/session_manager/bluma_app_dir.ts
 import path28 from "path";
@@ -20659,24 +20746,268 @@ function getPreferredAppDir() {
   return path28.resolve(expandHome(fixed));
 }
 
-// src/app/agent/session_manager/agent_session_paths.ts
+// src/app/agent/session_manager/session_index_db.ts
+import path29 from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { promises as fs27 } from "fs";
+import { createRequire } from "module";
 var AGENT_SESSION_PATHS_JSONL = "agent_session_paths.jsonl";
+var BLUMA_SESSION_DB_FILE = "bluma.sqlite";
+var SCHEMA_VERSION = 1;
+var dbInstance = null;
+var dbAppDir = null;
+var migratePromise = null;
+function loadSqlite() {
+  const nodeRequire = createRequire(import.meta.url);
+  return nodeRequire("better-sqlite3");
+}
+function getSessionDbPath(appDir = getPreferredAppDir()) {
+  return path29.join(appDir, BLUMA_SESSION_DB_FILE);
+}
+function normalizeRelativePath(relativePath) {
+  return relativePath.split(path29.sep).join("/");
+}
+async function walkSessionJsonFiles(dir, onFile) {
+  let entries;
+  try {
+    entries = await fs27.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const name = String(e.name);
+    const full = path29.join(dir, name);
+    if (e.isDirectory()) {
+      await walkSessionJsonFiles(full, onFile);
+    } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
+      await onFile(full);
+    }
+  }
+}
+async function loadJsonlEntries(appDir) {
+  const map = /* @__PURE__ */ new Map();
+  const indexFile = path29.join(appDir, AGENT_SESSION_PATHS_JSONL);
+  let raw;
+  try {
+    raw = await fs27.readFile(indexFile, "utf-8");
+  } catch {
+    return map;
+  }
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row.sessionId && typeof row.relativePath === "string") {
+        map.set(row.sessionId, {
+          relativePath: normalizeRelativePath(row.relativePath),
+          updatedAt: row.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString()
+        });
+      }
+    } catch {
+    }
+  }
+  return map;
+}
+function previewFromConversationHistory(history) {
+  for (const msg of history ?? []) {
+    if (msg.role !== "user") continue;
+    const c = msg.content;
+    if (typeof c !== "string") continue;
+    const t = c.trim();
+    if (!t || t.startsWith("[SKILL:")) continue;
+    const oneLine = t.replace(/\s+/g, " ");
+    return oneLine.length > 72 ? `${oneLine.slice(0, 72)}\u2026` : oneLine;
+  }
+  return "(no messages)";
+}
+async function readSessionMetaFromJson(absPath) {
+  const fallback = {
+    preview: "(no messages)",
+    createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+  try {
+    const raw = await fs27.readFile(absPath, "utf-8");
+    const data = JSON.parse(raw);
+    const createdAt = data.created_at ?? fallback.createdAt;
+    const updatedAt = data.last_updated ?? data.created_at ?? fallback.updatedAt;
+    return {
+      preview: previewFromConversationHistory(data.conversation_history),
+      createdAt,
+      updatedAt
+    };
+  } catch {
+    try {
+      const st = await fs27.stat(absPath);
+      const iso = new Date(st.mtimeMs).toISOString();
+      return { preview: fallback.preview, createdAt: iso, updatedAt: iso };
+    } catch {
+      return fallback;
+    }
+  }
+}
+async function runMigrationV1(db, appDir) {
+  const jsonl = await loadJsonlEntries(appDir);
+  const upsert = db.prepare(`
+    INSERT INTO agent_sessions (session_id, relative_path, created_at, updated_at, preview)
+    VALUES (@sessionId, @relativePath, @createdAt, @updatedAt, @preview)
+    ON CONFLICT(session_id) DO UPDATE SET
+      relative_path = excluded.relative_path,
+      updated_at = CASE
+        WHEN excluded.updated_at > agent_sessions.updated_at THEN excluded.updated_at
+        ELSE agent_sessions.updated_at
+      END,
+      preview = CASE
+        WHEN excluded.updated_at > agent_sessions.updated_at THEN excluded.preview
+        ELSE agent_sessions.preview
+      END
+  `);
+  const insertFromPath = async (sessionId, absPath, jsonlUpdatedAt) => {
+    let rel;
+    try {
+      rel = normalizeRelativePath(path29.relative(appDir, absPath));
+    } catch {
+      return;
+    }
+    const meta = await readSessionMetaFromJson(absPath);
+    const updatedAt = jsonlUpdatedAt && Date.parse(jsonlUpdatedAt) > Date.parse(meta.updatedAt) ? jsonlUpdatedAt : meta.updatedAt;
+    upsert.run({
+      sessionId,
+      relativePath: rel,
+      createdAt: meta.createdAt,
+      updatedAt,
+      preview: meta.preview
+    });
+  };
+  for (const [sessionId, entry] of jsonl) {
+    const full = path29.join(appDir, entry.relativePath.replace(/\//g, path29.sep));
+    try {
+      await fs27.access(full);
+      await insertFromPath(sessionId, full, entry.updatedAt);
+    } catch {
+      upsert.run({
+        sessionId,
+        relativePath: entry.relativePath,
+        createdAt: entry.updatedAt,
+        updatedAt: entry.updatedAt,
+        preview: "(no messages)"
+      });
+    }
+  }
+  const sessionsRoot = path29.join(appDir, "sessions");
+  const existing = db.prepare("SELECT session_id FROM agent_sessions").all();
+  const seen = new Set(existing.map((r) => r.session_id));
+  await walkSessionJsonFiles(sessionsRoot, async (absPath) => {
+    const sessionId = path29.basename(absPath, ".json");
+    if (!sessionId || seen.has(sessionId)) return;
+    seen.add(sessionId);
+    await insertFromPath(sessionId, absPath);
+  });
+  db.pragma(`user_version = ${SCHEMA_VERSION}`);
+}
+function applySchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_sessions (
+      session_id TEXT PRIMARY KEY NOT NULL,
+      relative_path TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      preview TEXT NOT NULL DEFAULT '(no messages)'
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_updated
+      ON agent_sessions(updated_at DESC);
+  `);
+}
+async function ensureSessionIndexDb(appDir = getPreferredAppDir()) {
+  if (dbInstance && dbAppDir === appDir) {
+    return dbInstance;
+  }
+  if (!migratePromise || dbAppDir !== appDir) {
+    migratePromise = (async () => {
+      if (dbInstance) {
+        try {
+          dbInstance.close();
+        } catch {
+        }
+        dbInstance = null;
+      }
+      const BetterSqlite3 = loadSqlite();
+      const dbPath = getSessionDbPath(appDir);
+      mkdirSync3(path29.dirname(dbPath), { recursive: true });
+      const db = new BetterSqlite3(dbPath);
+      db.pragma("journal_mode = WAL");
+      applySchema(db);
+      const version = db.pragma("user_version", { simple: true });
+      if (version < SCHEMA_VERSION) {
+        await runMigrationV1(db, appDir);
+      }
+      dbInstance = db;
+      dbAppDir = appDir;
+    })();
+  }
+  await migratePromise;
+  return dbInstance;
+}
+async function upsertSessionIndexRow(row, appDir = getPreferredAppDir()) {
+  const db = await ensureSessionIndexDb(appDir);
+  const stmt = db.prepare(`
+    INSERT INTO agent_sessions (session_id, relative_path, created_at, updated_at, preview)
+    VALUES (@sessionId, @relativePath, @createdAt, @updatedAt, @preview)
+    ON CONFLICT(session_id) DO UPDATE SET
+      relative_path = excluded.relative_path,
+      updated_at = excluded.updated_at,
+      preview = excluded.preview
+  `);
+  stmt.run({
+    sessionId: row.sessionId,
+    relativePath: normalizeRelativePath(row.relativePath),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    preview: row.preview
+  });
+}
+async function getSessionPathFromIndex(sessionId, appDir = getPreferredAppDir()) {
+  const db = await ensureSessionIndexDb(appDir);
+  const row = db.prepare("SELECT relative_path FROM agent_sessions WHERE session_id = ?").get(sessionId);
+  return row?.relative_path?.replace(/\//g, path29.sep) ?? null;
+}
+async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir()) {
+  const db = await ensureSessionIndexDb(appDir);
+  const rows = db.prepare(
+    `SELECT session_id, relative_path, created_at, updated_at, preview
+       FROM agent_sessions
+       ORDER BY updated_at DESC
+       LIMIT ?`
+  ).all(limit);
+  return rows.map((r) => ({
+    sessionId: r.session_id,
+    relativePath: r.relative_path.replace(/\//g, path29.sep),
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    preview: r.preview
+  }));
+}
+
+// src/app/agent/session_manager/agent_session_paths.ts
+var AGENT_SESSION_PATHS_JSONL2 = "agent_session_paths.jsonl";
 async function appendAgentSessionPath(sessionId, relativePath) {
   const app = getPreferredAppDir();
-  const indexFile = path29.join(app, AGENT_SESSION_PATHS_JSONL);
-  await fs27.mkdir(app, { recursive: true });
-  const line = JSON.stringify({
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const rel = relativePath.split(path30.sep).join("/");
+  await upsertSessionIndexRow({
     sessionId,
-    relativePath: relativePath.split(path29.sep).join("/"),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }) + "\n";
-  await fs27.appendFile(indexFile, line, "utf-8");
+    relativePath: rel,
+    createdAt: now2,
+    updatedAt: now2,
+    preview: "(no messages)"
+  });
 }
-async function resolveSessionRelativePathFromIndex(sessionId) {
-  const indexFile = path29.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL);
+async function resolveSessionRelativePathFromJsonl(sessionId) {
+  const indexFile = path30.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   let raw;
   try {
-    raw = await fs27.readFile(indexFile, "utf-8");
+    raw = await fs28.readFile(indexFile, "utf-8");
   } catch {
     return null;
   }
@@ -20685,37 +21016,42 @@ async function resolveSessionRelativePathFromIndex(sessionId) {
     try {
       const row = JSON.parse(lines[i]);
       if (row.sessionId === sessionId && typeof row.relativePath === "string") {
-        return row.relativePath.replace(/\//g, path29.sep);
+        return row.relativePath.replace(/\//g, path30.sep);
       }
     } catch {
     }
   }
   return null;
 }
-async function walkSessionJsonFiles(dir, onFile) {
+async function resolveSessionRelativePathFromIndex(sessionId) {
+  const fromDb = await getSessionPathFromIndex(sessionId);
+  if (fromDb) return fromDb;
+  return resolveSessionRelativePathFromJsonl(sessionId);
+}
+async function walkSessionJsonFiles2(dir, onFile) {
   let entries;
   try {
-    entries = await fs27.readdir(dir, { withFileTypes: true });
+    entries = await fs28.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path29.join(dir, name);
+    const full = path30.join(dir, name);
     if (e.isDirectory()) {
-      await walkSessionJsonFiles(full, onFile);
+      await walkSessionJsonFiles2(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
       await onFile(full);
     }
   }
 }
 async function findSessionFileGlobFallback(sessionId) {
-  const sessionsRoot = path29.join(getPreferredAppDir(), "sessions");
+  const sessionsRoot = path30.join(getPreferredAppDir(), "sessions");
   const state2 = { best: null };
-  await walkSessionJsonFiles(sessionsRoot, async (abs) => {
-    if (path29.basename(abs, ".json") !== sessionId) return;
+  await walkSessionJsonFiles2(sessionsRoot, async (abs) => {
+    if (path30.basename(abs, ".json") !== sessionId) return;
     try {
-      const st = await fs27.stat(abs);
+      const st = await fs28.stat(abs);
       if (!st.isFile()) return;
       if (!state2.best || st.mtimeMs > state2.best.m) {
         state2.best = { p: abs, m: st.mtimeMs };
@@ -20726,11 +21062,11 @@ async function findSessionFileGlobFallback(sessionId) {
   return state2.best !== null ? state2.best.p : null;
 }
 async function loadLatestIndexEntriesBySessionId() {
-  const indexFile = path29.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL);
+  const indexFile = path30.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   const map = /* @__PURE__ */ new Map();
   let raw;
   try {
-    raw = await fs27.readFile(indexFile, "utf-8");
+    raw = await fs28.readFile(indexFile, "utf-8");
   } catch {
     return map;
   }
@@ -20763,40 +21099,36 @@ function dateFolderFromRelativePath(relativePath) {
   }
   return null;
 }
-function previewFromConversationHistory(history) {
-  for (const msg of history ?? []) {
-    if (msg.role !== "user") continue;
-    const c = msg.content;
-    if (typeof c !== "string") continue;
-    const t = c.trim();
-    if (!t || t.startsWith("[SKILL:")) continue;
-    const oneLine = t.replace(/\s+/g, " ");
-    return oneLine.length > 72 ? `${oneLine.slice(0, 72)}\u2026` : oneLine;
-  }
-  return "(no messages)";
-}
-async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs) {
+async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs, opts) {
   let rel;
   try {
-    rel = path29.relative(getPreferredAppDir(), absPath);
+    rel = path30.relative(getPreferredAppDir(), absPath);
   } catch {
     rel = absPath;
   }
-  const dateFolder = dateFolderFromRelativePath(rel.split(path29.sep).join("/"));
-  let preview = "(no messages)";
+  const dateFolder = dateFolderFromRelativePath(rel.split(path30.sep).join("/"));
+  let preview = opts?.preview ?? "(no messages)";
   let lastActivityMs = lastMtimeMs;
-  try {
-    const raw = await fs27.readFile(absPath, "utf-8");
-    const data = JSON.parse(raw);
-    preview = previewFromConversationHistory(data.conversation_history);
-    const iso = data.last_updated || data.created_at;
-    if (iso) {
-      const parsed = Date.parse(iso);
-      if (Number.isFinite(parsed)) {
-        lastActivityMs = Math.max(lastMtimeMs, parsed);
+  if (opts?.updatedAtIso) {
+    const parsed = Date.parse(opts.updatedAtIso);
+    if (Number.isFinite(parsed)) {
+      lastActivityMs = Math.max(lastMtimeMs, parsed);
+    }
+  }
+  if (!opts?.preview || opts.preview === "(no messages)") {
+    try {
+      const raw = await fs28.readFile(absPath, "utf-8");
+      const data = JSON.parse(raw);
+      preview = previewFromConversationHistory(data.conversation_history);
+      const iso = data.last_updated || data.created_at;
+      if (iso) {
+        const parsed = Date.parse(iso);
+        if (Number.isFinite(parsed)) {
+          lastActivityMs = Math.max(lastActivityMs, parsed);
+        }
       }
+    } catch {
     }
-  } catch {
   }
   return {
     sessionId,
@@ -20809,13 +21141,29 @@ async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs) {
 }
 async function listAgentSessionsForResume(limit = 50) {
   const appDir = getPreferredAppDir();
-  const sessionsRoot = path29.join(appDir, "sessions");
+  await ensureSessionIndexDb(appDir);
+  const fromIndex = await listSessionsFromIndex(limit * 2, appDir);
   const map = /* @__PURE__ */ new Map();
-  await walkSessionJsonFiles(sessionsRoot, async (absPath) => {
-    const id = path29.basename(absPath, ".json");
+  for (const row of fromIndex) {
+    const full = path30.join(appDir, row.relativePath);
+    try {
+      const st = await fs28.stat(full);
+      if (!st.isFile()) continue;
+      map.set(row.sessionId, {
+        path: full,
+        lastMtimeMs: st.mtimeMs,
+        preview: row.preview,
+        updatedAt: row.updatedAt
+      });
+    } catch {
+    }
+  }
+  const sessionsRoot = path30.join(appDir, "sessions");
+  await walkSessionJsonFiles2(sessionsRoot, async (absPath) => {
+    const id = path30.basename(absPath, ".json");
     if (!id) return;
     try {
-      const st = await fs27.stat(absPath);
+      const st = await fs28.stat(absPath);
       if (!st.isFile()) return;
       const cur = map.get(id);
       if (!cur || st.mtimeMs > cur.lastMtimeMs) {
@@ -20827,9 +21175,9 @@ async function listAgentSessionsForResume(limit = 50) {
   const index = await loadLatestIndexEntriesBySessionId();
   for (const [sessionId, entry] of index) {
     if (map.has(sessionId)) continue;
-    const full = path29.join(appDir, entry.relativePath.replace(/\//g, path29.sep));
+    const full = path30.join(appDir, entry.relativePath.replace(/\//g, path30.sep));
     try {
-      const st = await fs27.stat(full);
+      const st = await fs28.stat(full);
       if (st.isFile()) {
         map.set(sessionId, { path: full, lastMtimeMs: st.mtimeMs });
       }
@@ -20838,7 +21186,10 @@ async function listAgentSessionsForResume(limit = 50) {
   }
   const enriched = await Promise.all(
     [...map.entries()].map(
-      ([sessionId, v]) => enrichCandidateFromFile(v.path, sessionId, v.lastMtimeMs)
+      ([sessionId, v]) => enrichCandidateFromFile(v.path, sessionId, v.lastMtimeMs, {
+        preview: v.preview,
+        updatedAtIso: v.updatedAt
+      })
     )
   );
   return enriched.sort((a, b) => b.lastActivityMs - a.lastActivityMs).slice(0, limit);
@@ -20883,10 +21234,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path30.dirname(dest);
-      await fs28.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path31.dirname(dest);
+      await fs29.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs28.rename(src, dest);
+      await fs29.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -20899,13 +21250,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs28.access(src);
-    const data = await fs28.readFile(src);
-    const dir = path30.dirname(dest);
-    await fs28.mkdir(dir, { recursive: true }).catch(() => {
+    await fs29.access(src);
+    const data = await fs29.readFile(src);
+    const dir = path31.dirname(dest);
+    await fs29.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs28.writeFile(dest, data);
-    await fs28.unlink(src).catch(() => {
+    await fs29.writeFile(dest, data);
+    await fs29.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -20918,23 +21269,23 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path30.join(appDir, "sessions");
-  await fs28.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path31.join(appDir, "sessions");
+  await fs29.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function resolveAgentSessionFilePath(sessionId) {
   const appDir = getPreferredAppDir();
-  const legacy = path30.join(appDir, "sessions", `${sessionId}.json`);
+  const legacy = path31.join(appDir, "sessions", `${sessionId}.json`);
   try {
-    await fs28.access(legacy);
+    await fs29.access(legacy);
     return legacy;
   } catch {
   }
   const rel = await resolveSessionRelativePathFromIndex(sessionId);
   if (rel) {
-    const full = path30.join(appDir, rel);
+    const full = path31.join(appDir, rel);
     try {
-      await fs28.access(full);
+      await fs29.access(full);
       return full;
     } catch {
     }
@@ -20947,7 +21298,7 @@ async function loadSession(sessionId) {
     return null;
   }
   try {
-    const fileContent = await fs28.readFile(sessionFile, "utf-8");
+    const fileContent = await fs29.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     const memory = {
       historyAnchor: sessionData.history_anchor ?? null,
@@ -20968,16 +21319,16 @@ async function loadOrcreateSession(sessionId) {
   const y = String(now2.getFullYear());
   const mo = String(now2.getMonth() + 1).padStart(2, "0");
   const d = String(now2.getDate()).padStart(2, "0");
-  const datedDir = path30.join(sessionsRoot, y, mo, d);
-  await fs28.mkdir(datedDir, { recursive: true });
-  const sessionFile = path30.join(datedDir, `${sessionId}.json`);
+  const datedDir = path31.join(sessionsRoot, y, mo, d);
+  await fs29.mkdir(datedDir, { recursive: true });
+  const sessionFile = path31.join(datedDir, `${sessionId}.json`);
   const newSessionData = {
     session_id: sessionId,
     created_at: now2.toISOString(),
     conversation_history: []
   };
-  await fs28.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
-  const relToApp = path30.relative(getPreferredAppDir(), sessionFile);
+  await fs29.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+  const relToApp = path31.relative(getPreferredAppDir(), sessionFile);
   await appendAgentSessionPath(sessionId, relToApp);
   const emptyMemory = {
     historyAnchor: null,
@@ -20989,12 +21340,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path30.dirname(sessionFile);
-      await fs28.mkdir(dir, { recursive: true });
+      const dir = path31.dirname(sessionFile);
+      await fs29.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs28.readFile(sessionFile, "utf-8");
+      const fileContent = await fs29.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -21005,14 +21356,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path30.basename(sessionFile, ".json");
+      const sessionId = path31.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs28.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs29.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -21028,8 +21379,26 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     }
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs28.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs29.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
+      const sessionId = sessionData.session_id ?? path31.basename(sessionFile, ".json");
+      const updatedAt = sessionData.last_updated ?? (/* @__PURE__ */ new Date()).toISOString();
+      const createdAt = sessionData.created_at ?? updatedAt;
+      let relToApp;
+      try {
+        relToApp = path31.relative(getPreferredAppDir(), sessionFile);
+      } catch {
+        relToApp = sessionFile;
+      }
+      await upsertSessionIndexRow({
+        sessionId,
+        relativePath: relToApp,
+        createdAt,
+        updatedAt,
+        preview: previewFromConversationHistory(
+          history
+        )
+      });
     } catch (writeError) {
       if (writeError instanceof Error) {
         console.error(`Fatal error saving session to ${sessionFile}: ${writeError.message}`);
@@ -21037,7 +21406,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs28.unlink(tempSessionFile);
+        await fs29.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -21052,16 +21421,30 @@ async function saveSessionHistory(sessionFile, history, memory) {
   });
   debouncedSave(sessionFile, cleanHistory, memory);
 }
+async function saveSessionHistoryNow(sessionFile, history, memory) {
+  const pending = pendingSaves.get(sessionFile);
+  if (pending) {
+    clearTimeout(pending.timer);
+    pendingSaves.delete(sessionFile);
+  }
+  const cleanHistory = history.filter((msg) => {
+    if (msg.role === "user" && typeof msg.content === "string") {
+      return !msg.content.startsWith("[SKILL:");
+    }
+    return true;
+  });
+  await doSaveSessionHistory(sessionFile, cleanHistory, memory);
+}
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os24 from "os";
-import fs35 from "fs";
-import path37 from "path";
+import fs36 from "fs";
+import path38 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs29 from "fs";
-import path31 from "path";
+import fs30 from "fs";
+import path32 from "path";
 import os20 from "os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var SkillLoader = class _SkillLoader {
@@ -21071,8 +21454,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path31.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path31.join(os20.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path32.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path32.join(os20.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -21081,48 +21464,48 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path31.join(process.cwd(), "dist", "config", "skills");
+      return path32.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path31.resolve(p);
+      const abs = path32.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path31.dirname(fileURLToPath3(import.meta.url));
-      push(path31.join(bundleDir, "config", "skills"));
+      const bundleDir = path32.dirname(fileURLToPath3(import.meta.url));
+      push(path32.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path31.isAbsolute(argv1) && fs29.existsSync(argv1)) {
-          resolved = fs29.realpathSync(argv1);
-        } else if (!path31.isAbsolute(argv1)) {
-          resolved = path31.resolve(process.cwd(), argv1);
+        if (path32.isAbsolute(argv1) && fs30.existsSync(argv1)) {
+          resolved = fs30.realpathSync(argv1);
+        } else if (!path32.isAbsolute(argv1)) {
+          resolved = path32.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path31.dirname(resolved);
-        argvBundled = path31.join(scriptDir, "config", "skills");
+        const scriptDir = path32.dirname(resolved);
+        argvBundled = path32.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
     }
     for (const abs of candidates) {
-      if (fs29.existsSync(abs)) {
+      if (fs30.existsSync(abs)) {
         return abs;
       }
     }
     try {
-      return path31.join(path31.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
+      return path32.join(path32.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path31.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path32.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -21151,8 +21534,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path31.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path31.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path32.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path32.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -21160,20 +21543,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs29.existsSync(dir)) return [];
+    if (!fs30.existsSync(dir)) return [];
     try {
-      return fs29.readdirSync(dir).filter((d) => {
-        const fullPath = path31.join(dir, d);
-        return fs29.statSync(fullPath).isDirectory() && fs29.existsSync(path31.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path31.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs30.readdirSync(dir).filter((d) => {
+        const fullPath = path32.join(dir, d);
+        return fs30.statSync(fullPath).isDirectory() && fs30.existsSync(path32.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path32.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs29.existsSync(skillPath)) return null;
+    if (!fs30.existsSync(skillPath)) return null;
     try {
-      const raw = fs29.readFileSync(skillPath, "utf-8");
+      const raw = fs30.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -21195,12 +21578,12 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path31.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path31.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path31.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs29.existsSync(bundledPath);
-    const existsProject = fs29.existsSync(projectPath);
-    const existsGlobal = fs29.existsSync(globalPath);
+    const bundledPath = path32.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path32.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path32.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs30.existsSync(bundledPath);
+    const existsProject = fs30.existsSync(projectPath);
+    const existsGlobal = fs30.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -21239,9 +21622,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs29.readFileSync(skillPath, "utf-8");
+      const raw = fs30.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path31.dirname(skillPath);
+      const skillDir = path32.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -21250,22 +21633,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path31.join(skillDir, "references")),
-        scripts: this.scanAssets(path31.join(skillDir, "scripts"))
+        references: this.scanAssets(path32.join(skillDir, "references")),
+        scripts: this.scanAssets(path32.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs29.existsSync(dir)) return [];
+    if (!fs30.existsSync(dir)) return [];
     try {
-      return fs29.readdirSync(dir).filter((f) => {
-        const fp = path31.join(dir, f);
-        return fs29.statSync(fp).isFile();
+      return fs30.readdirSync(dir).filter((f) => {
+        const fp = path32.join(dir, f);
+        return fs30.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path31.resolve(dir, f)
+        path: path32.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -21322,10 +21705,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path31.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path31.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path31.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs29.existsSync(bundledPath) || fs29.existsSync(projectPath) || fs29.existsSync(globalPath);
+    const bundledPath = path32.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path32.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path32.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs30.existsSync(bundledPath) || fs30.existsSync(projectPath) || fs30.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -21357,13 +21740,13 @@ var SkillLoader = class _SkillLoader {
 };
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
-import fs31 from "fs";
-import path33 from "path";
+import fs32 from "fs";
+import path34 from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/app/agent/utils/blumamd.ts
-import fs30 from "fs";
-import path32 from "path";
+import fs31 from "fs";
+import path33 from "path";
 import os21 from "os";
 import { execSync } from "child_process";
 var MEMORY_INSTRUCTION_PROMPT = "Instru\xE7\xF5es de mem\xF3ria do BluMa (BLUMA.md) est\xE3o abaixo. Siga estas instru\xE7\xF5es exatamente como escritas. Estas instru\xE7\xF5es OVERRIDE qualquer comportamento padr\xE3o.";
@@ -21493,12 +21876,12 @@ var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 function expandIncludePath(includePath, baseDir) {
   const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
   if (cleanPath.startsWith("~")) {
-    return path32.join(os21.homedir(), cleanPath.slice(1));
+    return path33.join(os21.homedir(), cleanPath.slice(1));
   }
-  if (path32.isAbsolute(cleanPath)) {
+  if (path33.isAbsolute(cleanPath)) {
     return cleanPath;
   }
-  return path32.resolve(baseDir, cleanPath);
+  return path33.resolve(baseDir, cleanPath);
 }
 function processIncludes(content, baseDir, processedFiles) {
   const lines = content.split("\n");
@@ -21507,20 +21890,20 @@ function processIncludes(content, baseDir, processedFiles) {
     const includeMatch = line.match(/^@\s*([^\s]+)/);
     if (includeMatch) {
       const includePath = expandIncludePath(includeMatch[1], baseDir);
-      const normalizedPath = path32.normalize(includePath);
+      const normalizedPath = path33.normalize(includePath);
       if (processedFiles.has(normalizedPath)) {
         result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
         continue;
       }
-      const ext = path32.extname(includePath).toLowerCase();
+      const ext = path33.extname(includePath).toLowerCase();
       if (!TEXT_FILE_EXTENSIONS.has(ext)) {
         result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
         continue;
       }
       try {
-        const includedContent = fs30.readFileSync(includePath, "utf-8");
+        const includedContent = fs31.readFileSync(includePath, "utf-8");
         processedFiles.add(normalizedPath);
-        const processedContent = processIncludes(includedContent, path32.dirname(includePath), processedFiles);
+        const processedContent = processIncludes(includedContent, path33.dirname(includePath), processedFiles);
         result.push(`
 <!-- BEGIN INCLUDE ${includeMatch[1]} -->
 `);
@@ -21566,9 +21949,9 @@ function parseFrontmatterPaths(paths2) {
 }
 function readMemoryFile(filePath, type, includeBasePath) {
   try {
-    const rawContent = fs30.readFileSync(filePath, "utf-8");
-    const baseDir = includeBasePath || path32.dirname(filePath);
-    const processedFiles = /* @__PURE__ */ new Set([path32.normalize(filePath)]);
+    const rawContent = fs31.readFileSync(filePath, "utf-8");
+    const baseDir = includeBasePath || path33.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path33.normalize(filePath)]);
     const { frontmatter, content: withoutFrontmatter } = parseFrontmatter(rawContent);
     const globs = parseFrontmatterPaths(frontmatter.paths);
     const processedContent = processIncludes(withoutFrontmatter, baseDir, processedFiles);
@@ -21590,15 +21973,15 @@ function readMemoryFile(filePath, type, includeBasePath) {
 }
 function findGitRoot(startDir) {
   let current = startDir;
-  while (current !== path32.dirname(current)) {
-    const gitPath = path32.join(current, ".git");
+  while (current !== path33.dirname(current)) {
+    const gitPath = path33.join(current, ".git");
     try {
-      if (fs30.existsSync(gitPath)) {
+      if (fs31.existsSync(gitPath)) {
         return current;
       }
     } catch {
     }
-    current = path32.dirname(current);
+    current = path33.dirname(current);
   }
   return null;
 }
@@ -21623,17 +22006,17 @@ function getGitUserInfo(cwd2) {
 }
 function processRulesDirectory(rulesDir, type, processedPaths, conditionalRule = false) {
   const result = [];
-  if (!fs30.existsSync(rulesDir)) {
+  if (!fs31.existsSync(rulesDir)) {
     return result;
   }
   try {
-    const entries = fs30.readdirSync(rulesDir, { withFileTypes: true });
+    const entries = fs31.readdirSync(rulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path32.join(rulesDir, entry.name);
+      const entryPath = path33.join(rulesDir, entry.name);
       if (entry.isDirectory()) {
         result.push(...processRulesDirectory(entryPath, type, processedPaths, conditionalRule));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const normalizedPath = path32.normalize(entryPath);
+        const normalizedPath = path33.normalize(entryPath);
         if (processedPaths.has(normalizedPath)) {
           continue;
         }
@@ -21669,13 +22052,13 @@ function loadManagedMemory() {
 function loadUserMemory() {
   const files = [];
   const homeDir = os21.homedir();
-  const userBlumaDir = path32.join(homeDir, ".bluma");
-  const userBlumaMd = path32.join(userBlumaDir, "BLUMA.md");
+  const userBlumaDir = path33.join(homeDir, ".bluma");
+  const userBlumaMd = path33.join(userBlumaDir, "BLUMA.md");
   const userFile = readMemoryFile(userBlumaMd, "User");
   if (userFile && userFile.content.trim()) {
     files.push(userFile);
   }
-  const userRulesDir = path32.join(userBlumaDir, "rules");
+  const userRulesDir = path33.join(userBlumaDir, "rules");
   const processedPaths = /* @__PURE__ */ new Set();
   files.push(...processRulesDirectory(userRulesDir, "User", processedPaths, false));
   return files;
@@ -21687,10 +22070,10 @@ function loadProjectMemory(cwd2) {
   let currentDir = cwd2;
   const MAX_TRAVERSAL_DEPTH = 20;
   let depth = 0;
-  const normalizedGitRoot = path32.resolve(gitRoot);
-  while (currentDir !== path32.dirname(currentDir) && path32.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
+  const normalizedGitRoot = path33.resolve(gitRoot);
+  while (currentDir !== path33.dirname(currentDir) && path33.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
     dirs.push(currentDir);
-    currentDir = path32.dirname(currentDir);
+    currentDir = path33.dirname(currentDir);
     depth++;
   }
   if (!dirs.includes(gitRoot)) {
@@ -21698,7 +22081,7 @@ function loadProjectMemory(cwd2) {
   }
   const processedPaths = /* @__PURE__ */ new Set();
   for (const dir of dirs.reverse()) {
-    const projectBlumaMd = path32.join(dir, "BLUMA.md");
+    const projectBlumaMd = path33.join(dir, "BLUMA.md");
     if (!processedPaths.has(projectBlumaMd)) {
       processedPaths.add(projectBlumaMd);
       const projectFile = readMemoryFile(projectBlumaMd, "Project");
@@ -21706,7 +22089,7 @@ function loadProjectMemory(cwd2) {
         files.push(projectFile);
       }
     }
-    const blumaDirBlumaMd = path32.join(dir, ".bluma", "BLUMA.md");
+    const blumaDirBlumaMd = path33.join(dir, ".bluma", "BLUMA.md");
     if (!processedPaths.has(blumaDirBlumaMd)) {
       processedPaths.add(blumaDirBlumaMd);
       const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "Project");
@@ -21714,10 +22097,10 @@ function loadProjectMemory(cwd2) {
         files.push(blumaDirFile);
       }
     }
-    const rulesDir = path32.join(dir, ".bluma", "rules");
+    const rulesDir = path33.join(dir, ".bluma", "rules");
     files.push(...processRulesDirectory(rulesDir, "Project", processedPaths, false));
   }
-  const localBlumaMd = path32.join(cwd2, "BLUMA.local.md");
+  const localBlumaMd = path33.join(cwd2, "BLUMA.local.md");
   if (!processedPaths.has(localBlumaMd)) {
     processedPaths.add(localBlumaMd);
     const localFile = readMemoryFile(localBlumaMd, "Local");
@@ -21803,10 +22186,10 @@ var LIMITS = {
 };
 function safeReadFile(filePath, maxChars) {
   try {
-    if (!fs31.existsSync(filePath)) return null;
-    const st = fs31.statSync(filePath);
+    if (!fs32.existsSync(filePath)) return null;
+    const st = fs32.statSync(filePath);
     if (!st.isFile()) return null;
-    const raw = fs31.readFileSync(filePath, "utf8");
+    const raw = fs32.readFileSync(filePath, "utf8");
     if (raw.includes("\0")) return null;
     if (raw.length <= maxChars) return raw;
     return `${raw.slice(0, maxChars)}
@@ -21818,7 +22201,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd2) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path33.join(cwd2, name), LIMITS.readme);
+    const c = safeReadFile(path34.join(cwd2, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -21826,14 +22209,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd2) {
   const paths2 = [
-    path33.join(cwd2, "BluMa.md"),
-    path33.join(cwd2, "BLUMA.md"),
-    path33.join(cwd2, ".bluma", "BluMa.md")
+    path34.join(cwd2, "BluMa.md"),
+    path34.join(cwd2, "BLUMA.md"),
+    path34.join(cwd2, ".bluma", "BluMa.md")
   ];
   for (const p of paths2) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path33.relative(cwd2, p) || p;
+      const rel = path34.relative(cwd2, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -21841,10 +22224,10 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd2) {
-  const p = path33.join(cwd2, "package.json");
+  const p = path34.join(cwd2, "package.json");
   try {
-    if (!fs31.existsSync(p)) return null;
-    const pkg = JSON.parse(fs31.readFileSync(p, "utf8"));
+    if (!fs32.existsSync(p)) return null;
+    const pkg = JSON.parse(fs32.readFileSync(p, "utf8"));
     const scripts = pkg.scripts;
     let scriptKeys = "";
     if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
@@ -21877,7 +22260,7 @@ function summarizePackageJson(cwd2) {
 }
 function topLevelListing(cwd2) {
   try {
-    const names = fs31.readdirSync(cwd2, { withFileTypes: true });
+    const names = fs32.readdirSync(cwd2, { withFileTypes: true });
     const sorted = [...names].sort((a, b) => a.name.localeCompare(b.name));
     const limited = sorted.slice(0, LIMITS.topDirEntries);
     const lines = limited.map((d) => `${d.name}${d.isDirectory() ? "/" : ""}`);
@@ -21935,7 +22318,7 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path33.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path34.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -21953,15 +22336,15 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path33.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path34.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path33.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path34.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path33.join(cwd2, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path34.join(cwd2, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -21997,14 +22380,14 @@ function buildWorkspaceSnapshot(cwd2) {
   } else {
     parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
   }
-  const tsconfig = safeReadFile(path33.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
+  const tsconfig = safeReadFile(path34.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
   if (tsconfig) {
     parts.push("### tsconfig.json (excerpt)\n```json");
     parts.push(tsconfig);
     parts.push("```\n");
   }
   for (const name of ["Dockerfile", "dockerfile", "Dockerfile.prod", "Dockerfile.dev"]) {
-    const df = safeReadFile(path33.join(cwd2, name), LIMITS.dockerfile);
+    const df = safeReadFile(path34.join(cwd2, name), LIMITS.dockerfile);
     if (df) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22014,7 +22397,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const dc = safeReadFile(path33.join(cwd2, name), LIMITS.dockerfile);
+    const dc = safeReadFile(path34.join(cwd2, name), LIMITS.dockerfile);
     if (dc) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22029,12 +22412,12 @@ function buildWorkspaceSnapshot(cwd2) {
     ".circleci/config.yml",
     "Jenkinsfile"
   ]) {
-    const ciFile = path33.join(cwd2, ciPath);
-    if (fs31.existsSync(ciFile)) {
-      const st = fs31.statSync(ciFile);
+    const ciFile = path34.join(cwd2, ciPath);
+    if (fs32.existsSync(ciFile)) {
+      const st = fs32.statSync(ciFile);
       if (st.isDirectory()) {
         try {
-          const wfFiles = fs31.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+          const wfFiles = fs32.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
           if (wfFiles.length > 0) {
             parts.push(`### GitHub Actions workflows
 \`${wfFiles.join("`, `")}\`
@@ -22045,7 +22428,7 @@ function buildWorkspaceSnapshot(cwd2) {
       } else {
         const ci = safeReadFile(ciFile, LIMITS.ciConfig);
         if (ci) {
-          parts.push(`### CI config (${path33.basename(ciPath)})
+          parts.push(`### CI config (${path34.basename(ciPath)})
 `);
           parts.push(ci);
           parts.push("\n");
@@ -22054,8 +22437,8 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const depFile of ["requirements.txt", "Pipfile", "poetry.lock", "Gemfile", "go.sum", "Cargo.lock"]) {
-    const depPath = path33.join(cwd2, depFile);
-    if (fs31.existsSync(depPath)) {
+    const depPath = path34.join(cwd2, depFile);
+    if (fs32.existsSync(depPath)) {
       const depContent = safeReadFile(depPath, 1500);
       if (depContent) {
         parts.push(`### ${depFile} (top entries)
@@ -22068,10 +22451,10 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
-    const envPath = path33.join(cwd2, envFile);
-    if (fs31.existsSync(envPath)) {
+    const envPath = path34.join(cwd2, envFile);
+    if (fs32.existsSync(envPath)) {
       try {
-        const raw = fs31.readFileSync(envPath, "utf-8");
+        const raw = fs32.readFileSync(envPath, "utf-8");
         const keys = raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => {
           const eqIndex = l.indexOf("=");
           return eqIndex >= 0 ? l.slice(0, eqIndex).trim() : l.trim();
@@ -22094,15 +22477,15 @@ init_runtime_config();
 
 // src/app/agent/runtime/plugin_registry.ts
 init_sandbox_policy();
-import fs32 from "fs";
+import fs33 from "fs";
 import os22 from "os";
-import path34 from "path";
+import path35 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path34.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path35.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path34.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
+  return path35.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -22111,11 +22494,11 @@ function getPluginDirs() {
   };
 }
 function readManifest(manifestPath, fallbackName) {
-  if (!fs32.existsSync(manifestPath)) {
+  if (!fs33.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs32.readFileSync(manifestPath, "utf-8"));
+    const parsed = JSON.parse(fs33.readFileSync(manifestPath, "utf-8"));
     return {
       name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : fallbackName,
       description: typeof parsed.description === "string" ? parsed.description.trim() : void 0,
@@ -22128,22 +22511,22 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path34.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path34.join(pluginDir, "plugin.json")
+    path35.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path35.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
-    if (fs32.existsSync(candidate)) {
+    if (fs33.existsSync(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 function listFromDir(baseDir, source) {
-  if (!fs32.existsSync(baseDir)) {
+  if (!fs33.existsSync(baseDir)) {
     return [];
   }
-  return fs32.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path34.join(baseDir, entry.name);
+  return fs33.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+    const pluginDir = path35.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -22588,8 +22971,8 @@ function buildModelInfoSection(modelId) {
 
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
-import fs33 from "fs";
-import path35 from "path";
+import fs34 from "fs";
+import path36 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -22600,7 +22983,7 @@ var cache3 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path35.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path36.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -22619,8 +23002,8 @@ function ensureLoaded2() {
     return cache3;
   }
   try {
-    if (fs33.existsSync(statePath)) {
-      const parsed = JSON.parse(fs33.readFileSync(statePath, "utf-8"));
+    if (fs34.existsSync(statePath)) {
+      const parsed = JSON.parse(fs34.readFileSync(statePath, "utf-8"));
       cache3 = {
         enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_STATE.enabled,
         maxEvents: typeof parsed.maxEvents === "number" && Number.isFinite(parsed.maxEvents) && parsed.maxEvents > 0 ? Math.floor(parsed.maxEvents) : DEFAULT_STATE.maxEvents,
@@ -22646,9 +23029,9 @@ function ensureLoaded2() {
 }
 function persist2(state2) {
   const statePath = getStatePath();
-  fs33.mkdirSync(path35.dirname(statePath), { recursive: true });
+  fs34.mkdirSync(path36.dirname(statePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs33.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
+  fs34.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
   cache3 = state2;
   cachePath2 = statePath;
 }
@@ -22898,18 +23281,18 @@ Usa s\xF3 facts do pedido; campos em falta \u2192 "n\xE3o fornecido" \u2014 nunc
 }
 
 // src/app/agent/core/prompt/auto_memory.ts
-import fs34 from "fs";
-import path36 from "path";
+import fs35 from "fs";
+import path37 from "path";
 import os23 from "os";
-var AUTO_MEMORY_FILE = path36.join(os23.homedir(), ".bluma", "auto_memory.md");
+var AUTO_MEMORY_FILE = path37.join(os23.homedir(), ".bluma", "auto_memory.md");
 var MAX_AUTO_MEMORY_CHARS = 25e3;
 var MAX_AUTO_MEMORY_LINES = 200;
 function getAutoMemoryForPrompt() {
   try {
-    if (!fs34.existsSync(AUTO_MEMORY_FILE)) {
+    if (!fs35.existsSync(AUTO_MEMORY_FILE)) {
       return "";
     }
-    let content = fs34.readFileSync(AUTO_MEMORY_FILE, "utf-8");
+    let content = fs35.readFileSync(AUTO_MEMORY_FILE, "utf-8");
     if (!content.trim()) {
       return "";
     }
@@ -22935,6 +23318,103 @@ function isAutoMemoryEnabled() {
   return true;
 }
 
+// src/app/agent/core/prompt/factorai_sh_prompt.ts
+var FACTORAI_SH_SECTION = `
+<factorai_sh_workflow>
+## FactorAI.sh \u2014 Next.js hosting (mandatory workflow)
+
+**When to load full checklist:** \`load_skill("factorai-sh")\` before any create/deploy/edit/redeploy task.
+
+### Backend URL (already in your environment)
+| 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.
+
+### 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.
+- Before any edit/redeploy on an **existing** app: read \`factorai.sh.json\` \u2192 use \`appContext.appId\` (UUID).
+- Never invent \`appId\` or duplicate state outside this file.
+
+### Tools (sandbox-only)
+| Tool | When |
+|------|------|
+| \`factorai.sh.create_next_app\` | New Next.js project in workspace |
+| \`factorai.sh.deploy_app\` | First deploy (ZIP source only) |
+| \`factorai.sh.apply_app_changes\` | **App already online** \u2014 patch files + rebuild (Vercel-like) |
+| \`factorai.sh.get_app_status\` | Poll build status after deploy/apply |
+| \`factorai.sh.redeploy_app\` | Rebuild current sources without file patches |
+
+---
+
+## Flow A \u2014 New app (no \`factorai.sh.json\` yet)
+
+1. \`factorai.sh.create_next_app({ name, template: "full" })\` \u2014 prefer **full** for deploy (App Router + \`app/\` + shadcn base). Minimal also includes \`app/\` but full is safer for UI tasks.
+2. Customize with \`edit_tool\` / \`file_write\` / \`shell_command\` in the project directory (e.g. \`./{name}/app/page.tsx\`).
+3. Optional: \`npx tsc --noEmit\` to catch TS errors \u2014 **avoid** \`npm run build\` before deploy (creates \`.next/\` and inflates the ZIP).
+4. \`factorai.sh.deploy_app({ projectDir: "./{name}", name })\` \u2014 tool excludes \`node_modules\`, \`.next\`, \`.env*\` automatically. **Never** manual \`zip\` including \`node_modules\` or \`.next\`.
+5. Persist returned IDs into \`factorai.sh.json\` (tool does this when possible). Report live URL in \`message(result)\` via \`factor-sh-url-app\` (from manifest \`appUrl\`, absolute URL \u2014 prefix with \`SEVERINO_URL\` only when manifest has a path).
+
+---
+
+## Session scope (mandatory)
+
+- App state lives **only** in **this** sandbox workspace (\`factorai.sh.json\` + project dir for this \`session_id\`).
+- **Never** assume an app from another chat/session \u2014 no cross-session \`appId\` guessing.
+- For edits: read \`factorai.sh.json\` in the **current** cwd first; if missing, the user must deploy/create the app **in this same session** before Flow B.
+
+## Flow B \u2014 App already deployed in this session (Vercel-style edit + rebuild)
+
+**Do NOT** re-run \`deploy_app\` for small edits. **Do NOT** only \`file_write\` locally and stop \u2014 that does not update the running host.
+
+1. Read \`factorai.sh.json\` in this workspace \u2192 \`appId\`.
+2. After \`edit_tool\` / \`file_write\`, **read the full file** you changed (\`read_file_lines\` or read entire file).
+3. \`factorai.sh.apply_app_changes({ appId, files: [{ path: "app/page.tsx", content: "<ENTIRE file contents>" }, ...], deploy: true })\`  
+   - **CRITICAL:** \`content\` must be the **complete** file body. The server **replaces** the whole file \u2014 a footer snippet or JSX fragment **destroys** the page.  
+   - One entry per changed path; each \`content\` = full file as on disk after your edit.  
+   - \`deploy\` defaults to \`true\`. Paths relative to app root (e.g. \`app/page.tsx\`). Blocked: \`node_modules\`, \`.next\`, \`.git\`.
+4. Poll until rebuild completes (see Polling below).
+5. Confirm live page, then \`message(result)\` with \`factor-sh-url-app\` from **this** session's manifest.
+
+Use \`factorai.sh.redeploy_app({ appId })\` only when sources on the server are already correct but build must run again (no file changes).
+
+---
+
+## Polling after deploy / apply_app_changes
+
+1. \`factorai.sh.get_app_status({ appId })\` or GET \`/api/v1/apps/{appId}\`.
+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\`.
+
+---
+
+## Deploy constraints (first deploy)
+
+- \`next.config.js\` must keep \`output: 'standalone'\` (included in scaffold).
+- ZIP max ~50MB \u2014 source only; Severino runs \`npm install\` + \`next build\` on the server.
+- shadcn components in scaffold must compile (no missing Radix imports).
+
+---
+
+## Reporting to orchestrator (Severino)
+
+- Progress: \`message({ message_type: "info", ... })\` every few steps.
+- Done: \`message({ message_type: "result", content: "...", attachments: [...], "factor-sh-url-app": "<live url>" })\` \u2014 **only \`result\` ends the worker turn**.
+- **Mandatory for Severino:** on every \`message(result)\` after deploy/redeploy, set \`"factor-sh-url-app"\` to the absolute live app URL from \`factorai.sh.json\` (\`appContext.appUrl\` + \`SEVERINO_URL\` when needed). Auto-filled if omitted; verify after polling \`ready\`.
+- File deliverables still use \`attachments[]\` under \`.bluma/artifacts/\` \u2014 separate from the app URL field.
+</factorai_sh_workflow>
+`;
+function isFactorAiShPromptEnabled() {
+  const isSandbox = process.env.BLUMA_SANDBOX === "true";
+  const baseUrl = (process.env.FACTORAI_BASE_URL || process.env.FACTORAI_URL || "").trim();
+  return isSandbox && Boolean(baseUrl);
+}
+
 // src/app/agent/core/prompt/prompt_builder.ts
 function getNodeVersion() {
   return process.version;
@@ -22966,17 +23446,17 @@ function getGitBranch(dir) {
   }
 }
 function getPackageManager(dir) {
-  if (fs35.existsSync(path37.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs35.existsSync(path37.join(dir, "yarn.lock"))) return "yarn";
-  if (fs35.existsSync(path37.join(dir, "bun.lockb"))) return "bun";
-  if (fs35.existsSync(path37.join(dir, "package-lock.json"))) return "npm";
+  if (fs36.existsSync(path38.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs36.existsSync(path38.join(dir, "yarn.lock"))) return "yarn";
+  if (fs36.existsSync(path38.join(dir, "bun.lockb"))) return "bun";
+  if (fs36.existsSync(path38.join(dir, "package-lock.json"))) return "npm";
   return "unknown";
 }
 function getProjectType(dir) {
   try {
-    const files = fs35.readdirSync(dir);
+    const files = fs36.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs35.readFileSync(path37.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs36.readFileSync(path38.join(dir, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.next) return "Next.js";
       if (deps.react) return "React";
@@ -22996,9 +23476,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path37.join(dir, "package.json");
-    if (fs35.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path38.join(dir, "package.json");
+    if (fs36.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -23007,7 +23487,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs35.existsSync(path37.join(dir, "pytest.ini")) || fs35.existsSync(path37.join(dir, "conftest.py"))) return "pytest";
+    if (fs36.existsSync(path38.join(dir, "pytest.ini")) || fs36.existsSync(path38.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -23015,9 +23495,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path37.join(dir, "package.json");
-    if (fs35.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path38.join(dir, "package.json");
+    if (fs36.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return "npm test";
       if (pkg.scripts?.["test:unit"]) return "npm run test:unit";
     }
@@ -23032,8 +23512,8 @@ function getTestCommand(dir) {
 }
 function isGitRepo(dir) {
   try {
-    const p = path37.join(dir, ".git");
-    return fs35.existsSync(p) && fs35.lstatSync(p).isDirectory();
+    const p = path38.join(dir, ".git");
+    return fs36.existsSync(p) && fs36.lstatSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -23234,7 +23714,8 @@ Timeouts mean the orchestrator should raise the limit \u2014 not that the sandbo
 - **Step 2:** \`message(result)\` with those paths in \`attachments[]\`; use \`content\` for a short summary only.
 - Never create a top-level \`./artifacts/\` folder \u2014 it is auto-remapped to \`.bluma/artifacts/\`.
 - **Never invent URLs** or paths outside \`.bluma/artifacts/\` in \`attachments[]\`.
-- Live deploy URLs (if any) may appear in \`content\` when returned by \`factorai.sh.deploy_app\`; downloadable files still go through \`attachments[]\`.
+- FactorAI.sh live app URL: on \`message(result)\` after deploy, set \`"factor-sh-url-app"\` (absolute URL). File paths still use \`attachments[]\` only.
+- Next.js hosting on FactorAI.sh: \`load_skill("factorai-sh")\` and follow \`<factorai_sh_workflow>\` when present.
 - **PDFs for mixed audiences:** load skill \`pdf\`; use \`create_report.py --from-json\` with \`audience: "mixed"\` \u2014 rigor in tables, \`plain_language\` callouts per section for non-specialists.
 - Remove temp files and generator scripts before finishing.
 </sandbox_context>
@@ -23288,12 +23769,18 @@ async function getUnifiedSystemPrompt(availableSkills, options) {
 
 ${SUBJECT_MACHINE_MODEL_XML}`;
     prompt += interpolate(SANDBOX_SECTION);
+    if (isFactorAiShPromptEnabled()) {
+      prompt += `
+
+${FACTORAI_SH_SECTION}`;
+    }
     const appContext = loadFactorAiAppContext();
     if (appContext) {
       prompt += `
 
-<factorai_app_context>
+<factorai_app_context active="true">
 ${formatFactorAiAppContextSummary(appContext)}
+Read factorai.sh.json before apply_app_changes or redeploy. Prefer apply_app_changes for edits to an already deployed app.
 </factorai_app_context>`;
     }
   }
@@ -23655,13 +24142,17 @@ var HistoryCompressor = class {
    */
   async buildContextWindow(fullHistory, llmService, userContext, options) {
     if (!fullHistory.length) {
-      return { messages: [], prunedHistory: null };
+      return { messages: [], prunedHistory: null, archivedMessages: [] };
     }
-    const toolDefinitionsTokens = countToolDefinitionsTokens(options?.toolDefinitions ?? []);
-    const tokenBudget = Math.max(
-      0,
-      (options?.tokenBudget ?? DEFAULT_CONTEXT_INPUT_BUDGET) - toolDefinitionsTokens
+    const budgetBreakdown = computeEffectiveInputBudget(
+      options?.tokenBudget ?? DEFAULT_CONTEXT_INPUT_BUDGET,
+      options?.toolDefinitions ?? [],
+      {
+        outputReserveTokens: options?.outputReserveTokens,
+        protocolOverheadTokens: options?.protocolOverheadTokens
+      }
     );
+    const tokenBudget = budgetBreakdown.effectiveBudget;
     const compressThreshold = options?.compressThreshold ?? COMPRESS_THRESHOLD;
     const keepRecentTurns = options?.keepRecentTurns ?? KEEP_RECENT_TURNS;
     const sanitized = sanitizeConversationForProvider(fullHistory);
@@ -23692,6 +24183,7 @@ var HistoryCompressor = class {
     });
     let compressionHappened = false;
     let compressionFailed = false;
+    const archivedMessages = [];
     while (tokens >= thresholdTokens && pendingSlices.length > 0 && !compressionFailed) {
       try {
         contextEventBus.emit("context:compression_progress", {
@@ -23701,6 +24193,7 @@ var HistoryCompressor = class {
           tokenCount: tokens,
           tokenBudget
         });
+        archivedMessages.push(...pendingFlat);
         this.anchor = await this.compressWithTimeout(
           pendingFlat,
           this.anchor,
@@ -23718,6 +24211,7 @@ var HistoryCompressor = class {
           "[HistoryCompressor] Compression failed/timeout, dropping old turns:",
           compressError?.message
         );
+        archivedMessages.push(...pendingFlat);
         pendingSlices = [];
         pendingFlat = [];
         sliceCount = recentStart;
@@ -23754,7 +24248,11 @@ var HistoryCompressor = class {
     } else {
       this.compressedSliceCount = sliceCount;
     }
-    return { messages, prunedHistory };
+    return {
+      messages,
+      prunedHistory,
+      archivedMessages: compressionHappened ? archivedMessages : []
+    };
   }
   // ── Private helpers ──────────────────────────────────────────────────────────
   /** Assembles system + anchor + pending + recent into the final message array. */
@@ -24436,9 +24934,9 @@ var LLMService = class {
 };
 
 // src/app/agent/utils/user_message_images.ts
-import fs36 from "fs";
+import fs37 from "fs";
 import os26 from "os";
-import path38 from "path";
+import path39 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
 var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
@@ -24454,22 +24952,22 @@ var MIME = {
 function expandUserPath(p) {
   const t = p.trim();
   if (t.startsWith("~")) {
-    return path38.join(os26.homedir(), t.slice(1).replace(/^\//, ""));
+    return path39.join(os26.homedir(), t.slice(1).replace(/^\//, ""));
   }
   return t;
 }
 function isPathAllowed(absResolved, cwd2) {
-  const resolved = path38.normalize(path38.resolve(absResolved));
-  const cwdR = path38.normalize(path38.resolve(cwd2));
-  const homeR = path38.normalize(path38.resolve(os26.homedir()));
-  const tmpR = path38.normalize(path38.resolve(os26.tmpdir()));
-  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path38.sep);
-  const underHome = resolved === homeR || resolved.startsWith(homeR + path38.sep);
-  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path38.sep);
+  const resolved = path39.normalize(path39.resolve(absResolved));
+  const cwdR = path39.normalize(path39.resolve(cwd2));
+  const homeR = path39.normalize(path39.resolve(os26.homedir()));
+  const tmpR = path39.normalize(path39.resolve(os26.tmpdir()));
+  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path39.sep);
+  const underHome = resolved === homeR || resolved.startsWith(homeR + path39.sep);
+  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path39.sep);
   return underCwd || underHome || underTmp;
 }
 function mimeFor(abs) {
-  const ext = path38.extname(abs).toLowerCase();
+  const ext = path39.extname(abs).toLowerCase();
   return MIME[ext] || "application/octet-stream";
 }
 var IMAGE_EXT_SRC = String.raw`(?:png|jpe?g|gif|webp|bmp)`;
@@ -24513,10 +25011,10 @@ function collectImagePathStrings(raw) {
 }
 function resolveImagePath(candidate, cwd2) {
   const expanded = expandUserPath(candidate);
-  const abs = path38.isAbsolute(expanded) ? path38.normalize(expanded) : path38.normalize(path38.resolve(cwd2, expanded));
+  const abs = path39.isAbsolute(expanded) ? path39.normalize(expanded) : path39.normalize(path39.resolve(cwd2, expanded));
   if (!isPathAllowed(abs, cwd2)) return null;
   try {
-    if (!fs36.existsSync(abs) || !fs36.statSync(abs).isFile()) return null;
+    if (!fs37.existsSync(abs) || !fs37.statSync(abs).isFile()) return null;
   } catch {
     return null;
   }
@@ -24536,11 +25034,11 @@ function trySingleLineFileUriOrBareImagePath(line, cwd2) {
   if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
     s = s.slice(1, -1).trim();
   }
-  if (!IMAGE_EXT.test(path38.extname(s))) return null;
+  if (!IMAGE_EXT.test(path39.extname(s))) return null;
   const abs = resolveImagePath(s, cwd2);
   if (!abs) return null;
   try {
-    const st = fs36.statSync(abs);
+    const st = fs37.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -24575,7 +25073,7 @@ function tryPasteChunkAsSingleImagePath(chunk, cwd2) {
     return null;
   }
   try {
-    const st = fs36.statSync(abs);
+    const st = fs37.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -24604,7 +25102,7 @@ function buildUserMessageContent(raw, cwd2) {
     const abs = resolveImagePath(c, cwd2);
     if (!abs) continue;
     try {
-      const st = fs36.statSync(abs);
+      const st = fs37.statSync(abs);
       if (st.size > MAX_IMAGE_BYTES) continue;
     } catch {
       continue;
@@ -24621,7 +25119,7 @@ function buildUserMessageContent(raw, cwd2) {
   }
   const parts = [{ type: "text", text: textPart }];
   for (const abs of resolvedAbs) {
-    const buf = fs36.readFileSync(abs);
+    const buf = fs37.readFileSync(abs);
     const b64 = buf.toString("base64");
     const mime = mimeFor(abs);
     parts.push({
@@ -24639,7 +25137,7 @@ function buildUserMessageContent(raw, cwd2) {
 init_sandbox_policy();
 init_runtime_config();
 init_permission_rules();
-import path39 from "path";
+import path40 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";
@@ -24654,11 +25152,11 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (!filePath) {
     return { allowed: false, reason: "No file path provided for permission check." };
   }
-  const resolvedPath = path39.resolve(filePath);
+  const resolvedPath = path40.resolve(filePath);
   if (!isPathInsideWorkspace(resolvedPath, policy)) {
     return { allowed: false, reason: `File path "${filePath}" is outside workspace root.` };
   }
-  const relativePath = path39.relative(policy.workspaceRoot, resolvedPath);
+  const relativePath = path40.relative(policy.workspaceRoot, resolvedPath);
   const toolPattern = `${toolName}(${relativePath})`;
   const ruleDecision = permissionRulesEngine.checkPermission(toolPattern, { filepath: filePath });
   if (ruleDecision === "deny") {
@@ -24667,7 +25165,7 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (ruleDecision === "allow") {
     return { allowed: true, reason: `File "${filePath}" allowed by permission rules.` };
   }
-  const dirPath = path39.dirname(relativePath);
+  const dirPath = path40.dirname(relativePath);
   const dirPattern = `${toolName}(${dirPath}/**)`;
   const dirRuleDecision = permissionRulesEngine.checkPermission(dirPattern, { filepath: filePath });
   if (dirRuleDecision === "allow") {
@@ -24884,11 +25382,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryConsolidate.ts
-import * as fs37 from "fs";
-import * as path40 from "path";
+import * as fs38 from "fs";
+import * as path41 from "path";
 import os27 from "os";
 function memoryPath2() {
-  return path40.join(process.env.HOME || os27.homedir(), ".bluma", "coding_memory.json");
+  return path41.join(process.env.HOME || os27.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -24898,18 +25396,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath2();
-  if (!fs37.existsSync(p)) {
+  if (!fs38.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs37.copyFileSync(p, bak);
+    fs38.copyFileSync(p, bak);
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `backup failed: ${e.message}` };
   }
   let data;
   try {
-    data = JSON.parse(fs37.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs38.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -24944,7 +25442,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs37.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs38.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -25448,6 +25946,22 @@ var BluMaToolRunner = class {
   }
 };
 
+// src/app/agent/session_manager/session_archive.ts
+import path42 from "path";
+import { promises as fs39 } from "fs";
+async function archivePrunedConversationMessages(sessionId, messages) {
+  if (!sessionId || messages.length === 0) {
+    return null;
+  }
+  const appDir = getPreferredAppDir();
+  const dir = path42.join(appDir, "sessions", "archive", sessionId);
+  await fs39.mkdir(dir, { recursive: true });
+  const archiveFile = path42.join(dir, `${Date.now()}.jsonl`);
+  const lines = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+  await fs39.appendFile(archiveFile, lines, "utf-8");
+  return archiveFile;
+}
+
 // src/app/agent/core/llm/llm_errors.ts
 function isContextWindowValidationError(error) {
   const rawMessage = error instanceof Error ? error.message : typeof error === "string" ? error : "";
@@ -25792,7 +26306,11 @@ var BluMaTurnCoordinator = class {
       for (let attempt = 0; attempt < tokenBudgets.length; attempt += 1) {
         const tokenBudget = tokenBudgets[attempt];
         try {
-          const { messages: contextWindow, prunedHistory } = await this.deps.compressor.buildContextWindow(
+          const {
+            messages: contextWindow,
+            prunedHistory,
+            archivedMessages
+          } = await this.deps.compressor.buildContextWindow(
             this.deps.history,
             this.deps.llm,
             this.deps.getLlmUserContext(),
@@ -25805,13 +26323,19 @@ var BluMaTurnCoordinator = class {
             history_length: this.deps.history.length,
             context_window_length: contextWindow.length,
             pruned_history_length: prunedHistory?.length ?? null,
+            archived_messages: archivedMessages.length,
             token_budget: tokenBudget,
             context_preview: summarizeHistoryForLog(contextWindow, 8)
           });
           if (prunedHistory) {
+            if (archivedMessages.length > 0) {
+              await archivePrunedConversationMessages(this.deps.sessionId, archivedMessages);
+            }
             this.deps.history.splice(0, this.deps.history.length, ...prunedHistory);
+            await this.deps.persistSessionAfterPrune();
+          } else {
+            this.deps.persistSession();
           }
-          this.deps.persistSession();
           if (typeof llmService.chatCompletionStream === "function") {
             await this.handleStreamingResponse(contextWindow);
           } else {
@@ -26229,6 +26753,7 @@ var BluMaAgent = class {
       getLlmUserContext: () => this.getLlmUserContext(),
       persistSession: () => this.persistSession(),
       persistSessionSync: () => this.persistSessionSync(),
+      persistSessionAfterPrune: () => this.persistSessionAfterPrune(),
       notifyFactorTurnEndIfNeeded: (reason) => this.notifyFactorTurnEndIfNeeded(reason),
       emitTurnCompleted: () => this.emitTurnCompleted(),
       generateEditPreview: (toolArgs) => this._generateEditPreview(toolArgs),
@@ -26268,13 +26793,13 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     try {
       const sessionData = {
-        session_id: path41.basename(this.sessionFile, ".json"),
+        session_id: path43.basename(this.sessionFile, ".json"),
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: this.history,
         last_updated: (/* @__PURE__ */ new Date()).toISOString(),
         ...this.compressor.getSnapshot()
       };
-      fs38.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      fs40.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
     } catch (error) {
       console.error("[Bluma] Failed to persist session synchronously:", error);
     }
@@ -26284,6 +26809,11 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     void saveSessionHistory(this.sessionFile, this.history, this.getMemorySnapshot());
   }
+  /** Gravação imediata após prune (histórico cortado + anchor no JSON de sessão). */
+  async persistSessionAfterPrune() {
+    if (!this.sessionFile) return;
+    await saveSessionHistoryNow(this.sessionFile, this.history, this.getMemorySnapshot());
+  }
   recordUiSlashCommand(command, mode = "visible_only") {
     const text = String(command ?? "").trim();
     if (!text) return;
@@ -26475,7 +27005,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path41.basename(toolArgs.file_path);
+      const filename = path43.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}`;
@@ -27201,16 +27731,16 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 }
 
 // src/app/agent/core/memory/session_memory.ts
-import fs39 from "fs";
+import fs41 from "fs";
 import os30 from "os";
-import path42 from "path";
+import path44 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path42.join(os30.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path44.join(os30.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -27267,15 +27797,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);
-    fs39.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
+    fs41.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
   }
   /**
    * Load memories from disk
    */
   async loadMemories() {
     try {
-      if (!fs39.existsSync(this.memoryFile)) return [];
-      const data = fs39.readFileSync(this.memoryFile, "utf-8");
+      if (!fs41.existsSync(this.memoryFile)) return [];
+      const data = fs41.readFileSync(this.memoryFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return [];
@@ -27819,14 +28349,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path54, handler) {
-    this.routeHandlers.set(path54, handler);
+  registerRoute(path56, handler) {
+    this.routeHandlers.set(path56, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext, options } = payload;
-    for (const [path54, handler] of this.routeHandlers) {
-      if (inputText === path54 || inputText.startsWith(`${path54} `)) {
+    for (const [path56, handler] of this.routeHandlers) {
+      if (inputText === path56 || inputText.startsWith(`${path56} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -27835,13 +28365,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path43 from "path";
+import path45 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 = path43.resolve(p.root, entry);
+    const abs = path45.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -27862,7 +28392,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path44.join(os31.homedir(), ".bluma", ".env");
+var globalEnvPath = path46.join(os31.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -29718,10 +30248,10 @@ function resolveToolPayload(result) {
 
 // src/app/ui/components/FilePathLink.tsx
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import path46 from "node:path";
+import path48 from "node:path";
 
 // src/app/ui/utils/pathDisplay.ts
-import path45 from "node:path";
+import path47 from "node:path";
 import os32 from "node:os";
 function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
   let s = String(pathInput ?? "").trim();
@@ -29729,17 +30259,17 @@ function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
     s = s.replace(/[/\\]+$/, "");
   }
   if (!s) return "";
-  const abs = path45.isAbsolute(s) ? path45.normalize(s) : path45.resolve(cwd2, s);
-  const resolvedCwd = path45.resolve(cwd2);
-  const rel = path45.relative(resolvedCwd, abs);
-  if (rel === "" || !rel.startsWith("..") && !path45.isAbsolute(rel)) {
+  const abs = path47.isAbsolute(s) ? path47.normalize(s) : path47.resolve(cwd2, s);
+  const resolvedCwd = path47.resolve(cwd2);
+  const rel = path47.relative(resolvedCwd, abs);
+  if (rel === "" || !rel.startsWith("..") && !path47.isAbsolute(rel)) {
     return rel === "" ? "." : rel;
   }
-  const home = path45.normalize(os32.homedir());
-  if (abs === home || abs.startsWith(home + path45.sep)) {
+  const home = path47.normalize(os32.homedir());
+  if (abs === home || abs.startsWith(home + path47.sep)) {
     return "~" + abs.slice(home.length);
   }
-  return path45.basename(abs);
+  return path47.basename(abs);
 }
 
 // src/app/ui/components/FilePathLink.tsx
@@ -29749,7 +30279,7 @@ function FilePathLink({ filePath, children, cwd: cwd2 = process.cwd(), color })
   if (!raw) {
     return null;
   }
-  const abs = path46.isAbsolute(raw) ? path46.normalize(raw) : path46.resolve(cwd2, raw);
+  const abs = path48.isAbsolute(raw) ? path48.normalize(raw) : path48.resolve(cwd2, raw);
   const href = pathToFileURL3(abs).href;
   const label = formatPathForDisplay(abs, cwd2);
   const text = typeof children === "string" ? children : label;
@@ -31701,12 +32231,12 @@ function patchToUnifiedDiffText(filePath, patch) {
 }
 
 // src/app/ui/utils/readEditContext.ts
-import { promises as fs40 } from "fs";
+import { promises as fs42 } from "fs";
 var CHUNK_SIZE = 64 * 1024;
 var CONTEXT_LINES2 = 3;
 async function openForScan(filePath) {
   try {
-    return await fs40.open(filePath, "r");
+    return await fs42.open(filePath, "r");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
@@ -32384,13 +32914,13 @@ function EditToolDiffPanel({
   newString,
   replaceAll = false
 }) {
-  const path54 = filePath.trim() || "unknown file";
+  const path56 = 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: path54,
+      filePath: path56,
       oldString,
       newString,
       replaceAll,
@@ -32428,7 +32958,7 @@ function renderToolUseMessage12({ args }) {
   return /* @__PURE__ */ jsx44(Text, { color: BLUMA_TERMINAL.blue, children: p });
 }
 function renderToolHeader12({ args }) {
-  const path54 = args?.file_path ?? ".";
+  const path56 = 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);
@@ -32438,7 +32968,7 @@ function renderToolHeader12({ args }) {
       action,
       /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
         " ",
-        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path54, color: BLUMA_TERMINAL.dim })
+        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path56, color: BLUMA_TERMINAL.dim })
       ] })
     ] }),
     /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
@@ -32830,11 +33360,11 @@ function userFacingName13() {
 }
 function renderToolUseMessage14({ args }) {
   const q = args?.query ? `"${args.query}"` : "...";
-  const path54 = args?.path || ".";
+  const path56 = 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: path54, color: BLUMA_TERMINAL.dim })
+    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path56, color: BLUMA_TERMINAL.dim })
   ] });
 }
 function renderToolHeader14({ args }) {
@@ -33356,7 +33886,7 @@ var loadSkillTool = createTool({
 });
 
 // src/app/agent/tools/FileWriteTool/UI.tsx
-import fs41 from "fs";
+import fs43 from "fs";
 import { diffLines as diffLines3 } from "diff";
 import { jsx as jsx54, jsxs as jsxs37 } from "react/jsx-runtime";
 function getFilePath(args) {
@@ -33371,7 +33901,7 @@ function getFilePath(args) {
 function readExistingFileText(filePath) {
   if (!filePath) return "";
   try {
-    return fs41.readFileSync(filePath, "utf-8");
+    return fs43.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -36301,8 +36831,8 @@ import {
 
 // src/app/ui/hooks/useAtCompletion.ts
 import { useEffect as useEffect11, useRef as useRef4, useState as useState13 } from "react";
-import fs42 from "fs";
-import path47 from "path";
+import fs44 from "fs";
+import path49 from "path";
 var MAX_RESULTS3 = 50;
 var DEFAULT_RECURSIVE_DEPTH = 2;
 function listPathSuggestions(baseDir, pattern) {
@@ -36310,7 +36840,7 @@ function listPathSuggestions(baseDir, pattern) {
   const patternEndsWithSlash = raw.endsWith("/");
   const relDir = raw.replace(/^\/+|\/+$/g, "");
   const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
-  const listDir = path47.resolve(baseDir, relDir || ".");
+  const listDir = path49.resolve(baseDir, relDir || ".");
   const results = [];
   const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
   const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
@@ -36327,7 +36857,7 @@ function listPathSuggestions(baseDir, pattern) {
   }
   function pushEntry(entryPath, label, isDir) {
     if (results.length >= MAX_RESULTS3) return;
-    const clean = label.split(path47.sep).join("/").replace(/[]+/g, "");
+    const clean = label.split(path49.sep).join("/").replace(/[]+/g, "");
     results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
   }
   try {
@@ -36336,11 +36866,11 @@ function listPathSuggestions(baseDir, pattern) {
       while (queue.length && results.length < MAX_RESULTS3) {
         const node = queue.shift();
         try {
-          const entries = fs42.readdirSync(node.dir, { withFileTypes: true });
+          const entries = fs44.readdirSync(node.dir, { withFileTypes: true });
           for (const entry of entries) {
             if (isIgnoredName(entry.name)) continue;
-            const entryAbs = path47.join(node.dir, entry.name);
-            const entryRel = node.rel ? path47.posix.join(node.rel, entry.name) : entry.name;
+            const entryAbs = path49.join(node.dir, entry.name);
+            const entryRel = node.rel ? path49.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());
@@ -36353,13 +36883,13 @@ function listPathSuggestions(baseDir, pattern) {
         }
       }
     } else {
-      const entries = fs42.readdirSync(listDir, { withFileTypes: true });
+      const entries = fs44.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 = path47.join(listDir, entry.name);
-        const label = relDir ? path47.posix.join(relDir, entry.name) : entry.name;
+        const entryAbs = path49.join(listDir, entry.name);
+        const label = relDir ? path49.posix.join(relDir, entry.name) : entry.name;
         pushEntry(entryAbs, label, entry.isDirectory());
         if (results.length >= MAX_RESULTS3) break;
       }
@@ -36560,15 +37090,15 @@ var SlashSubmenuInlineComponent = ({ menu }) => {
 var SlashSubmenuInline = memo15(SlashSubmenuInlineComponent);
 
 // src/app/ui/utils/clipboardImage.ts
-import fs43 from "fs";
+import fs45 from "fs";
 import os33 from "os";
-import path48 from "path";
+import path50 from "path";
 import { spawn as spawn5, execFile as execFileCb, execSync as execSync4 } from "child_process";
 import { promisify as promisify2 } from "util";
 
 // src/app/utils/clipboardNative.ts
 import { existsSync as existsSync7 } from "fs";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { dirname as dirname4, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __dirname;
@@ -36616,7 +37146,7 @@ function getNativeModule() {
     throw loadError;
   }
   try {
-    const require2 = createRequire(import.meta.url);
+    const require2 = createRequire2(import.meta.url);
     const mod = require2(nativePath);
     nativeModule = mod;
     return nativeModule;
@@ -36691,8 +37221,8 @@ function commandOnPath(cmd) {
 function unixClipboardHelperDirs() {
   const h = os33.homedir();
   return [
-    path48.join(h, ".local", "bin"),
-    path48.join(h, "bin"),
+    path50.join(h, ".local", "bin"),
+    path50.join(h, "bin"),
     "/usr/bin",
     "/usr/local/bin",
     "/bin",
@@ -36710,16 +37240,16 @@ function resolveHelperBinary(cmd) {
     return cmd;
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path48.join(dir, cmd);
+    const full = path50.join(dir, cmd);
     try {
-      fs43.accessSync(full, fs43.constants.X_OK);
+      fs45.accessSync(full, fs45.constants.X_OK);
       return full;
     } catch {
     }
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path48.join(dir, cmd);
-    if (fs43.existsSync(full)) {
+    const full = path50.join(dir, cmd);
+    if (fs45.existsSync(full)) {
       return full;
     }
   }
@@ -36760,17 +37290,17 @@ function writeBufferIfImage(baseDir, buf) {
   if (!ext) {
     return null;
   }
-  const out = path48.join(
+  const out = path50.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
-  fs43.writeFileSync(out, buf);
+  fs45.writeFileSync(out, buf);
   return out;
 }
 function unlinkQuiet(p) {
   try {
-    if (fs43.existsSync(p)) {
-      fs43.unlinkSync(p);
+    if (fs45.existsSync(p)) {
+      fs45.unlinkSync(p);
     }
   } catch {
   }
@@ -36787,25 +37317,25 @@ async function tryDarwinClipboardy(baseDir) {
       return null;
     }
     for (const src of tmpPaths) {
-      if (!src || !fs43.existsSync(src)) {
+      if (!src || !fs45.existsSync(src)) {
         continue;
       }
       let st;
       try {
-        st = fs43.statSync(src);
+        st = fs45.statSync(src);
       } catch {
         continue;
       }
       if (st.size < 80 || st.size > CLIPBOARD_MAX_BYTES) {
         continue;
       }
-      const ext = path48.extname(src).toLowerCase();
+      const ext = path50.extname(src).toLowerCase();
       const safeExt = ext && /^\.(png|jpe?g|gif|webp)$/i.test(ext) ? ext : ".png";
-      const out = path48.join(
+      const out = path50.join(
         baseDir,
         `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${safeExt}`
       );
-      fs43.copyFileSync(src, out);
+      fs45.copyFileSync(src, out);
       for (const p of tmpPaths) {
         unlinkQuiet(p);
       }
@@ -36819,14 +37349,14 @@ async function tryDarwinClipboardy(baseDir) {
   return null;
 }
 async function tryWindowsPowerShell(outFile) {
-  const ps = process.env.SystemRoot != null ? path48.join(
+  const ps = process.env.SystemRoot != null ? path50.join(
     process.env.SystemRoot,
     "System32",
     "WindowsPowerShell",
     "v1.0",
     "powershell.exe"
   ) : "powershell.exe";
-  if (!fs43.existsSync(ps)) {
+  if (!fs45.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";
@@ -36848,7 +37378,7 @@ async function tryWindowsPowerShell(outFile) {
     return false;
   }
   try {
-    const st = fs43.statSync(outFile);
+    const st = fs45.statSync(outFile);
     return st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES;
   } catch {
     return false;
@@ -36920,8 +37450,8 @@ function parseClipboardTextAsImagePath(raw) {
     s = s.slice(1, -1);
   }
   s = s.trim();
-  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path48.extname(s))) return null;
-  const abs = path48.isAbsolute(s) ? path48.normalize(s) : path48.resolve(process.cwd(), s);
+  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path50.extname(s))) return null;
+  const abs = path50.isAbsolute(s) ? path50.normalize(s) : path50.resolve(process.cwd(), s);
   return abs;
 }
 async function tryClipboardTextAsImageFile(baseDir) {
@@ -36935,19 +37465,19 @@ async function tryClipboardTextAsImageFile(baseDir) {
   const abs = parseClipboardTextAsImagePath(t);
   if (!abs) return null;
   try {
-    if (!fs43.existsSync(abs)) return null;
-    const st = fs43.statSync(abs);
+    if (!fs45.existsSync(abs)) return null;
+    const st = fs45.statSync(abs);
     if (!st.isFile() || st.size > CLIPBOARD_MAX_BYTES || st.size < 20) return null;
   } catch {
     return null;
   }
-  const ext = path48.extname(abs).toLowerCase();
-  const out = path48.join(
+  const ext = path50.extname(abs).toLowerCase();
+  const out = path50.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
   try {
-    fs43.copyFileSync(abs, out);
+    fs45.copyFileSync(abs, out);
     return out;
   } catch {
     return null;
@@ -36957,7 +37487,7 @@ async function tryLinuxShellPipelineSave(baseDir) {
   if (process.platform !== "linux" && process.platform !== "freebsd") {
     return null;
   }
-  const outPath = path48.join(
+  const outPath = path50.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`
   );
@@ -36979,11 +37509,11 @@ printf '%s' "$OUT"
       maxBuffer: 4096
     });
     const written = String(stdout ?? "").trim();
-    if (written !== outPath || !fs43.existsSync(outPath)) {
+    if (written !== outPath || !fs45.existsSync(outPath)) {
       unlinkQuiet(outPath);
       return null;
     }
-    const buf = fs43.readFileSync(outPath);
+    const buf = fs45.readFileSync(outPath);
     unlinkQuiet(outPath);
     return writeBufferIfImage(baseDir, buf);
   } catch {
@@ -37004,8 +37534,8 @@ async function tryNativeClipboardImage() {
   }
   try {
     const result = readClipboardImageNative();
-    if (fs43.existsSync(result.path)) {
-      const st = fs43.statSync(result.path);
+    if (fs45.existsSync(result.path)) {
+      const st = fs45.statSync(result.path);
       if (st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES) {
         return result.path;
       }
@@ -37015,8 +37545,8 @@ async function tryNativeClipboardImage() {
   return null;
 }
 async function readClipboardImageToTempFile() {
-  const baseDir = path48.join(os33.homedir(), ".cache", "bluma", "clipboard");
-  fs43.mkdirSync(baseDir, { recursive: true });
+  const baseDir = path50.join(os33.homedir(), ".cache", "bluma", "clipboard");
+  fs45.mkdirSync(baseDir, { recursive: true });
   const nativeResult = await tryNativeClipboardImage();
   if (nativeResult) {
     return nativeResult;
@@ -37034,7 +37564,7 @@ async function readClipboardImageToTempFile() {
     }
   }
   if (process.platform === "win32") {
-    const outFile = path48.join(
+    const outFile = path50.join(
       baseDir,
       `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`
     );
@@ -37075,7 +37605,7 @@ function expandLargePastePlaceholder(value, pending) {
 }
 
 // src/app/ui/components/InputPrompt.tsx
-import fs44 from "fs";
+import fs46 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 " }) });
@@ -37242,7 +37772,7 @@ var InputPrompt = memo16(({
           return;
         }
         if (routeText.startsWith("/")) {
-          const isFilePath = map.size > 0 && fs44.existsSync(routeText.split(/\s+/)[0]);
+          const isFilePath = map.size > 0 && fs46.existsSync(routeText.split(/\s+/)[0]);
           if (isFilePath) {
             uiEventBus.emit("user_overlay", {
               kind: "message",
@@ -39522,8 +40052,8 @@ var renderCode = () => {
 };
 
 // src/app/agent/core/thread/thread_store.ts
-import path49 from "path";
-import { promises as fs45 } from "fs";
+import path51 from "path";
+import { promises as fs47 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 var INDEX_VERSION = 1;
 var fileLocks2 = /* @__PURE__ */ new Map();
@@ -39548,9 +40078,9 @@ var ThreadStore = class {
   packageVersion;
   constructor() {
     const appDir = getPreferredAppDir();
-    this.threadsDir = path49.join(appDir, "threads");
-    this.archiveDir = path49.join(this.threadsDir, "archive");
-    this.indexPath = path49.join(this.threadsDir, "index.json");
+    this.threadsDir = path51.join(appDir, "threads");
+    this.archiveDir = path51.join(this.threadsDir, "archive");
+    this.indexPath = path51.join(this.threadsDir, "index.json");
     this.packageVersion = process.env.npm_package_version || "0.0.0";
   }
   // ==================== Inicialização ====================
@@ -39558,10 +40088,10 @@ var ThreadStore = class {
    * Inicializa o diretório de threads
    */
   async initialize() {
-    await fs45.mkdir(this.threadsDir, { recursive: true });
-    await fs45.mkdir(this.archiveDir, { recursive: true });
+    await fs47.mkdir(this.threadsDir, { recursive: true });
+    await fs47.mkdir(this.archiveDir, { recursive: true });
     try {
-      await fs45.access(this.indexPath);
+      await fs47.access(this.indexPath);
     } catch {
       await this.saveIndex({ version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
     }
@@ -39590,7 +40120,7 @@ var ThreadStore = class {
   async loadIndex() {
     return withFileLock2(this.indexPath, async () => {
       try {
-        const content = await fs45.readFile(this.indexPath, "utf-8");
+        const content = await fs47.readFile(this.indexPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return { version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
@@ -39601,8 +40131,8 @@ var ThreadStore = class {
     return withFileLock2(this.indexPath, async () => {
       index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
       const tempPath = `${this.indexPath}.${Date.now()}.tmp`;
-      await fs45.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
-      await fs45.rename(tempPath, this.indexPath);
+      await fs47.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
+      await fs47.rename(tempPath, this.indexPath);
     });
   }
   // ==================== Git Info ====================
@@ -39672,7 +40202,7 @@ var ThreadStore = class {
       messages: params.initialMessages || []
     };
     const historyPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs45.mkdir(path49.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path51.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -39727,7 +40257,7 @@ var ThreadStore = class {
       compressedSliceCount: source.history.compressedSliceCount
     };
     const historyPath = this.buildDatedThreadHistoryPath(newThreadId);
-    await fs45.mkdir(path49.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path51.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -39800,9 +40330,9 @@ var ThreadStore = class {
     const entry = index.threads[entryIndex];
     if (entry.status === "archived") return true;
     const oldPath = entry.historyPath || this.getLegacyHistoryPath(threadId);
-    const newPath = path49.join(this.archiveDir, `${threadId}.jsonl`);
+    const newPath = path51.join(this.archiveDir, `${threadId}.jsonl`);
     try {
-      await fs45.rename(oldPath, newPath);
+      await fs47.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -39823,11 +40353,11 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     if (entry.status === "active") return true;
-    const oldPath = path49.join(this.archiveDir, `${threadId}.jsonl`);
+    const oldPath = path51.join(this.archiveDir, `${threadId}.jsonl`);
     const newPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs45.mkdir(path49.dirname(newPath), { recursive: true });
+    await fs47.mkdir(path51.dirname(newPath), { recursive: true });
     try {
-      await fs45.rename(oldPath, newPath);
+      await fs47.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -39848,7 +40378,7 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     try {
-      await fs45.unlink(entry.historyPath);
+      await fs47.unlink(entry.historyPath);
     } catch {
     }
     index.threads.splice(entryIndex, 1);
@@ -39858,28 +40388,28 @@ var ThreadStore = class {
   }
   // ==================== Histórico ====================
   getLegacyHistoryPath(threadId) {
-    return path49.join(this.threadsDir, `${threadId}.jsonl`);
+    return path51.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 path49.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
+    return path51.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 fs45.access(entry.historyPath);
+        await fs47.access(entry.historyPath);
         return entry.historyPath;
       } catch {
       }
     }
     const legacy = this.getLegacyHistoryPath(threadId);
     try {
-      await fs45.access(legacy);
+      await fs47.access(legacy);
       return legacy;
     } catch {
       return entry?.historyPath ?? legacy;
@@ -39896,9 +40426,9 @@ var ThreadStore = class {
     for (const msg of history.messages) {
       lines.push(JSON.stringify({ type: "message", ...msg }));
     }
-    await fs45.mkdir(path49.dirname(historyPath), { recursive: true }).catch(() => {
+    await fs47.mkdir(path51.dirname(historyPath), { recursive: true }).catch(() => {
     });
-    await fs45.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs47.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
   }
   /**
    * Guarda o histórico de uma thread
@@ -39920,7 +40450,7 @@ var ThreadStore = class {
     ].filter((p, i, arr) => Boolean(p) && arr.indexOf(p) === i);
     for (const historyPath of pathsToTry) {
       try {
-        const content = await fs45.readFile(historyPath, "utf-8");
+        const content = await fs47.readFile(historyPath, "utf-8");
         const lines = content.split("\n").filter(Boolean);
         const history = {
           threadId,
@@ -39955,7 +40485,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 fs45.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs47.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.saveIndex(index);
   }
@@ -42828,16 +43358,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import path50 from "path";
-import fs46 from "fs";
+import path52 from "path";
+import fs48 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 = path50.join(dir, "package.json");
-    if (fs46.existsSync(candidate)) {
+    const candidate = path52.join(dir, "package.json");
+    if (fs48.existsSync(candidate)) {
       try {
-        const raw = fs46.readFileSync(candidate, "utf8");
+        const raw = fs48.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -42845,7 +43375,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path50.dirname(dir);
+    const parent = path52.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -42854,13 +43384,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path50.resolve(dir);
+    const abs = path52.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path50.dirname(fileURLToPath6(import.meta.url)));
+    const fromBundle = tryFrom(path52.dirname(fileURLToPath6(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -42868,12 +43398,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path50.isAbsolute(argv1) && fs46.existsSync(argv1)) {
-        resolved = fs46.realpathSync(argv1);
+      if (path52.isAbsolute(argv1) && fs48.existsSync(argv1)) {
+        resolved = fs48.realpathSync(argv1);
       } else {
-        resolved = path50.resolve(process.cwd(), argv1);
+        resolved = path52.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path50.dirname(resolved));
+      const fromArgv = tryFrom(path52.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -43692,16 +44222,16 @@ function usePlanMode() {
 
 // src/app/hooks/useAgentMode.ts
 import { useState as useState22, useEffect as useEffect21, useCallback as useCallback9 } from "react";
-import * as fs47 from "fs";
-import * as path51 from "path";
+import * as fs49 from "fs";
+import * as path53 from "path";
 import { homedir as homedir3 } from "os";
-var SETTINGS_PATH = path51.join(homedir3(), ".bluma", "settings.json");
+var SETTINGS_PATH = path53.join(homedir3(), ".bluma", "settings.json");
 function readAgentModeFromFile() {
   try {
-    if (!fs47.existsSync(SETTINGS_PATH)) {
+    if (!fs49.existsSync(SETTINGS_PATH)) {
       return "default";
     }
-    const content = fs47.readFileSync(SETTINGS_PATH, "utf-8");
+    const content = fs49.readFileSync(SETTINGS_PATH, "utf-8");
     const settings = JSON.parse(content);
     return settings.agentMode || "default";
   } catch (error) {
@@ -43720,16 +44250,16 @@ function useAgentMode() {
   }, []);
   const updateAgentMode = useCallback9((mode) => {
     try {
-      if (!fs47.existsSync(SETTINGS_PATH)) {
-        fs47.mkdirSync(path51.dirname(SETTINGS_PATH), { recursive: true });
+      if (!fs49.existsSync(SETTINGS_PATH)) {
+        fs49.mkdirSync(path53.dirname(SETTINGS_PATH), { recursive: true });
       }
       let settings = {};
-      if (fs47.existsSync(SETTINGS_PATH)) {
-        const content = fs47.readFileSync(SETTINGS_PATH, "utf-8");
+      if (fs49.existsSync(SETTINGS_PATH)) {
+        const content = fs49.readFileSync(SETTINGS_PATH, "utf-8");
         settings = JSON.parse(content);
       }
       settings.agentMode = mode;
-      fs47.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+      fs49.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
       setAgentMode(mode);
     } catch (error) {
       console.error("Failed to update agent mode:", error);
@@ -44992,10 +45522,10 @@ import React39 from "react";
 import { memo as memo26, useCallback as useCallback11, useEffect as useEffect23, useMemo as useMemo8, useState as useState25 } from "react";
 
 // src/app/agent/session_manager/session_resume_browser.ts
-import path52 from "path";
-import { promises as fs48 } from "fs";
+import path54 from "path";
+import { promises as fs50 } from "fs";
 function getSessionsRoot() {
-  return path52.join(getPreferredAppDir(), "sessions");
+  return path54.join(getPreferredAppDir(), "sessions");
 }
 function normalizeSessionsCwd(cwd2) {
   return cwd2.replace(/\\/g, "/").split("/").filter((p) => p && p !== "." && p !== "..").join("/");
@@ -45016,9 +45546,9 @@ async function sessionEntryFromFile(absPath, sessionId) {
   let preview = "(no messages)";
   let lastActivityMs = Date.now();
   try {
-    const st = await fs48.stat(absPath);
+    const st = await fs50.stat(absPath);
     lastActivityMs = st.mtimeMs;
-    const raw = await fs48.readFile(absPath, "utf-8");
+    const raw = await fs50.readFile(absPath, "utf-8");
     const data = JSON.parse(raw);
     preview = previewFromHistory(data.conversation_history);
     const iso = data.last_updated || data.created_at;
@@ -45046,15 +45576,15 @@ function compareDirNames(a, b) {
 async function listSessionBrowserEntries(cwdRel) {
   const cwd2 = normalizeSessionsCwd(cwdRel);
   const root = getSessionsRoot();
-  const absDir = cwd2 ? path52.join(root, ...cwd2.split("/")) : root;
+  const absDir = cwd2 ? path54.join(root, ...cwd2.split("/")) : root;
   const out = [];
   if (cwd2) {
     out.push({ kind: "up", label: ".." });
   }
   let dirents;
   try {
-    await fs48.mkdir(absDir, { recursive: true });
-    dirents = await fs48.readdir(absDir, { withFileTypes: true });
+    await fs50.mkdir(absDir, { recursive: true });
+    dirents = await fs50.readdir(absDir, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -45063,7 +45593,7 @@ async function listSessionBrowserEntries(cwdRel) {
   for (const e of dirents) {
     const name = String(e.name);
     if (name.startsWith(".")) continue;
-    const full = path52.join(absDir, name);
+    const full = path54.join(absDir, name);
     if (e.isDirectory()) {
       dirNames.push(name);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -45073,7 +45603,7 @@ async function listSessionBrowserEntries(cwdRel) {
   dirNames.sort(compareDirNames);
   const sessions = [];
   for (const { name, full } of sessionFiles) {
-    const sessionId = path52.basename(name, ".json");
+    const sessionId = path54.basename(name, ".json");
     sessions.push(await sessionEntryFromFile(full, sessionId));
   }
   sessions.sort((a, b) => {
@@ -45380,15 +45910,19 @@ function resolveResultUserMessage(lastAssistantMessage, lastAttachments) {
   }
   return "Tarefa conclu\xEDda.";
 }
-function buildSuccessResultData(envelope, sessionId, lastAssistantMessage, lastAttachments) {
+function buildSuccessResultData(envelope, sessionId, lastAssistantMessage, lastAttachments, lastFactorShUrlApp) {
   const message2 = resolveResultUserMessage(lastAssistantMessage, lastAttachments);
-  return {
+  const data = {
     message_id: envelope.message_id || sessionId,
     action: envelope.action || "unknown",
     last_assistant_message: message2,
     message: message2,
     attachments: lastAttachments
   };
+  if (lastFactorShUrlApp) {
+    data[FACTOR_SH_URL_APP_FIELD] = lastFactorShUrlApp;
+  }
+  return data;
 }
 function finalizeSession(sessionId, status, metadata) {
   updateSession(sessionId, {
@@ -45434,9 +45968,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs49.readFileSync(filePath, "utf-8");
+      rawPayload = fs51.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs49.readFileSync(0, "utf-8");
+      rawPayload = fs51.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -45472,6 +46006,15 @@ async function runAgentMode() {
     if (envelope.metadata?.sandbox_name) {
       process.env.BLUMA_SANDBOX_NAME = String(envelope.metadata.sandbox_name);
     }
+  } else if (process.env.BLUMA_SANDBOX_WORKSPACE?.trim()) {
+    process.env.BLUMA_SANDBOX = "true";
+    if (!process.env.BLUMA_SANDBOX_NAME?.trim()) {
+      process.env.BLUMA_SANDBOX_NAME = "sandbox-api";
+    }
+  }
+  const severinoUrl = (process.env.SEVERINO_URL || "").trim();
+  if (!(process.env.FACTORAI_BASE_URL || process.env.FACTORAI_URL || "").trim() && severinoUrl) {
+    process.env.FACTORAI_BASE_URL = severinoUrl;
   }
   const envelopeUserRequest = typeof envelope.context === "object" && envelope.context !== null ? String(
     envelope.context.user_request ?? envelope.context.userRequest ?? ""
@@ -45510,6 +46053,7 @@ async function runAgentMode() {
   });
   let lastAssistantMessage = null;
   let lastAttachments = null;
+  let lastFactorShUrlApp = null;
   let resultEmitted = false;
   let agentRef = null;
   let reasoningSequence = 0;
@@ -45560,6 +46104,16 @@ async function runAgentMode() {
         if (Array.isArray(attachments)) {
           lastAttachments = attachments.filter((p) => typeof p === "string");
         }
+        const factorUrl = messagePayload?.[FACTOR_SH_URL_APP_FIELD] ?? parsed?.[FACTOR_SH_URL_APP_FIELD] ?? parsed?.data?.[FACTOR_SH_URL_APP_FIELD];
+        if (typeof factorUrl === "string" && factorUrl.trim()) {
+          lastFactorShUrlApp = factorUrl.trim();
+        }
+        if (!lastFactorShUrlApp && extractMessageToolPayload(parsed)?.message_type === "result") {
+          const fromArgs = payload?.arguments?.[FACTOR_SH_URL_APP_FIELD];
+          if (typeof fromArgs === "string" && fromArgs.trim()) {
+            lastFactorShUrlApp = fromArgs.trim();
+          }
+        }
       } catch {
       }
     }
@@ -45576,7 +46130,8 @@ async function runAgentMode() {
           envelope,
           sessionId,
           lastAssistantMessage,
-          lastAttachments
+          lastAttachments,
+          lastFactorShUrlApp
         )
       });
       finalizeSession(sessionId, "completed", { finishedBy: "done-event" });
@@ -45628,7 +46183,8 @@ async function runAgentMode() {
           envelope,
           sessionId,
           lastAssistantMessage,
-          lastAttachments
+          lastAttachments,
+          lastFactorShUrlApp
         )
       });
       finalizeSession(sessionId, "completed", { finishedBy: "post-turn-fallback" });
@@ -45655,9 +46211,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path53.dirname(fileURLToPath7(import.meta.url));
-    const pkgPath = path53.join(base, "..", "package.json");
-    const j = JSON.parse(fs49.readFileSync(pkgPath, "utf8"));
+    const base = path55.dirname(fileURLToPath7(import.meta.url));
+    const pkgPath = path55.join(base, "..", "package.json");
+    const j = JSON.parse(fs51.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -45783,7 +46339,7 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs49.readFileSync(filePath, "utf-8");
+  const rawPayload = fs51.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
   const sessionId = envelope.session_id || envelope.message_id || uuidv412();
   registerSession({