@nomad-e/bluma-cli 0.14.1 → 0.15.0

package/dist/main.js

@@ -2479,7 +2479,7 @@ var init_CtxInspectTool = __esm({
 });
 
 // src/app/agent/session_manager/session_index_db.ts
-import path31 from "path";
+import path32 from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 import { promises as fs28 } from "fs";
 import { createRequire } from "module";
@@ -2488,10 +2488,10 @@ function loadSqlite() {
   return nodeRequire("better-sqlite3");
 }
 function getSessionDbPath(appDir = getPreferredAppDir()) {
-  return path31.join(appDir, BLUMA_SESSION_DB_FILE);
+  return path32.join(appDir, BLUMA_SESSION_DB_FILE);
 }
 function normalizeRelativePath(relativePath) {
-  return relativePath.split(path31.sep).join("/");
+  return relativePath.split(path32.sep).join("/");
 }
 async function walkSessionJsonFiles(dir, onFile) {
   let entries;
@@ -2502,7 +2502,7 @@ async function walkSessionJsonFiles(dir, onFile) {
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path31.join(dir, name);
+    const full = path32.join(dir, name);
     if (e.isDirectory()) {
       await walkSessionJsonFiles(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -2512,7 +2512,7 @@ async function walkSessionJsonFiles(dir, onFile) {
 }
 async function loadJsonlEntries(appDir) {
   const map = /* @__PURE__ */ new Map();
-  const indexFile = path31.join(appDir, AGENT_SESSION_PATHS_JSONL);
+  const indexFile = path32.join(appDir, AGENT_SESSION_PATHS_JSONL);
   let raw;
   try {
     raw = await fs28.readFile(indexFile, "utf-8");
@@ -2592,7 +2592,7 @@ async function runMigrationV1(db, appDir) {
   const insertFromPath = async (sessionId, absPath, jsonlUpdatedAt) => {
     let rel;
     try {
-      rel = normalizeRelativePath(path31.relative(appDir, absPath));
+      rel = normalizeRelativePath(path32.relative(appDir, absPath));
     } catch {
       return;
     }
@@ -2607,7 +2607,7 @@ async function runMigrationV1(db, appDir) {
     });
   };
   for (const [sessionId, entry] of jsonl) {
-    const full = path31.join(appDir, entry.relativePath.replace(/\//g, path31.sep));
+    const full = path32.join(appDir, entry.relativePath.replace(/\//g, path32.sep));
     try {
       await fs28.access(full);
       await insertFromPath(sessionId, full, entry.updatedAt);
@@ -2621,11 +2621,11 @@ async function runMigrationV1(db, appDir) {
       });
     }
   }
-  const sessionsRoot = path31.join(appDir, "sessions");
+  const sessionsRoot = path32.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 = path31.basename(absPath, ".json");
+    const sessionId = path32.basename(absPath, ".json");
     if (!sessionId || seen.has(sessionId)) return;
     seen.add(sessionId);
     await insertFromPath(sessionId, absPath);
@@ -2660,7 +2660,7 @@ async function ensureSessionIndexDb(appDir = getPreferredAppDir()) {
       }
       const BetterSqlite3 = loadSqlite();
       const dbPath = getSessionDbPath(appDir);
-      mkdirSync3(path31.dirname(dbPath), { recursive: true });
+      mkdirSync3(path32.dirname(dbPath), { recursive: true });
       const db = new BetterSqlite3(dbPath);
       db.pragma("journal_mode = WAL");
       applySchema(db);
@@ -2696,7 +2696,7 @@ async function upsertSessionIndexRow(row, appDir = getPreferredAppDir()) {
 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, path31.sep) ?? null;
+  return row?.relative_path?.replace(/\//g, path32.sep) ?? null;
 }
 async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir()) {
   const db = await ensureSessionIndexDb(appDir);
@@ -2708,7 +2708,7 @@ async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir())
   ).all(limit);
   return rows.map((r) => ({
     sessionId: r.session_id,
-    relativePath: r.relative_path.replace(/\//g, path31.sep),
+    relativePath: r.relative_path.replace(/\//g, path32.sep),
     createdAt: r.created_at,
     updatedAt: r.updated_at,
     preview: r.preview
@@ -2729,12 +2729,12 @@ var init_session_index_db = __esm({
 });
 
 // src/app/agent/session_manager/agent_session_paths.ts
-import path32 from "path";
+import path33 from "path";
 import { promises as fs29 } from "fs";
 async function appendAgentSessionPath(sessionId, relativePath) {
   const app = getPreferredAppDir();
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const rel = relativePath.split(path32.sep).join("/");
+  const rel = relativePath.split(path33.sep).join("/");
   await upsertSessionIndexRow({
     sessionId,
     relativePath: rel,
@@ -2744,7 +2744,7 @@ async function appendAgentSessionPath(sessionId, relativePath) {
   });
 }
 async function resolveSessionRelativePathFromJsonl(sessionId) {
-  const indexFile = path32.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path33.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   let raw;
   try {
     raw = await fs29.readFile(indexFile, "utf-8");
@@ -2756,7 +2756,7 @@ async function resolveSessionRelativePathFromJsonl(sessionId) {
     try {
       const row = JSON.parse(lines[i]);
       if (row.sessionId === sessionId && typeof row.relativePath === "string") {
-        return row.relativePath.replace(/\//g, path32.sep);
+        return row.relativePath.replace(/\//g, path33.sep);
       }
     } catch {
     }
@@ -2777,7 +2777,7 @@ async function walkSessionJsonFiles2(dir, onFile) {
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path32.join(dir, name);
+    const full = path33.join(dir, name);
     if (e.isDirectory()) {
       await walkSessionJsonFiles2(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -2786,10 +2786,10 @@ async function walkSessionJsonFiles2(dir, onFile) {
   }
 }
 async function findSessionFileGlobFallback(sessionId) {
-  const sessionsRoot = path32.join(getPreferredAppDir(), "sessions");
+  const sessionsRoot = path33.join(getPreferredAppDir(), "sessions");
   const state2 = { best: null };
   await walkSessionJsonFiles2(sessionsRoot, async (abs) => {
-    if (path32.basename(abs, ".json") !== sessionId) return;
+    if (path33.basename(abs, ".json") !== sessionId) return;
     try {
       const st = await fs29.stat(abs);
       if (!st.isFile()) return;
@@ -2802,7 +2802,7 @@ async function findSessionFileGlobFallback(sessionId) {
   return state2.best !== null ? state2.best.p : null;
 }
 async function loadLatestIndexEntriesBySessionId() {
-  const indexFile = path32.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path33.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   const map = /* @__PURE__ */ new Map();
   let raw;
   try {
@@ -2842,11 +2842,11 @@ function dateFolderFromRelativePath(relativePath) {
 async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs, opts) {
   let rel;
   try {
-    rel = path32.relative(getPreferredAppDir(), absPath);
+    rel = path33.relative(getPreferredAppDir(), absPath);
   } catch {
     rel = absPath;
   }
-  const dateFolder = dateFolderFromRelativePath(rel.split(path32.sep).join("/"));
+  const dateFolder = dateFolderFromRelativePath(rel.split(path33.sep).join("/"));
   let preview = opts?.preview ?? "(no messages)";
   let lastActivityMs = lastMtimeMs;
   if (opts?.updatedAtIso) {
@@ -2885,7 +2885,7 @@ async function listAgentSessionsForResume(limit = 50) {
   const fromIndex = await listSessionsFromIndex(limit * 2, appDir);
   const map = /* @__PURE__ */ new Map();
   for (const row of fromIndex) {
-    const full = path32.join(appDir, row.relativePath);
+    const full = path33.join(appDir, row.relativePath);
     try {
       const st = await fs29.stat(full);
       if (!st.isFile()) continue;
@@ -2898,9 +2898,9 @@ async function listAgentSessionsForResume(limit = 50) {
     } catch {
     }
   }
-  const sessionsRoot = path32.join(appDir, "sessions");
+  const sessionsRoot = path33.join(appDir, "sessions");
   await walkSessionJsonFiles2(sessionsRoot, async (absPath) => {
-    const id = path32.basename(absPath, ".json");
+    const id = path33.basename(absPath, ".json");
     if (!id) return;
     try {
       const st = await fs29.stat(absPath);
@@ -2915,7 +2915,7 @@ async function listAgentSessionsForResume(limit = 50) {
   const index = await loadLatestIndexEntriesBySessionId();
   for (const [sessionId, entry] of index) {
     if (map.has(sessionId)) continue;
-    const full = path32.join(appDir, entry.relativePath.replace(/\//g, path32.sep));
+    const full = path33.join(appDir, entry.relativePath.replace(/\//g, path33.sep));
     try {
       const st = await fs29.stat(full);
       if (st.isFile()) {
@@ -2945,7 +2945,7 @@ var init_agent_session_paths = __esm({
 });
 
 // src/app/agent/session_manager/session_manager.ts
-import path33 from "path";
+import path34 from "path";
 import { promises as fs30 } from "fs";
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -2982,7 +2982,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path33.dirname(dest);
+      const dir = path34.dirname(dest);
       await fs30.mkdir(dir, { recursive: true }).catch(() => {
       });
       await fs30.rename(src, dest);
@@ -3000,7 +3000,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   try {
     await fs30.access(src);
     const data = await fs30.readFile(src);
-    const dir = path33.dirname(dest);
+    const dir = path34.dirname(dest);
     await fs30.mkdir(dir, { recursive: true }).catch(() => {
     });
     await fs30.writeFile(dest, data);
@@ -3017,13 +3017,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path33.join(appDir, "sessions");
+  const sessionDir = path34.join(appDir, "sessions");
   await fs30.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function resolveAgentSessionFilePath(sessionId) {
   const appDir = getPreferredAppDir();
-  const legacy = path33.join(appDir, "sessions", `${sessionId}.json`);
+  const legacy = path34.join(appDir, "sessions", `${sessionId}.json`);
   try {
     await fs30.access(legacy);
     return legacy;
@@ -3031,7 +3031,7 @@ async function resolveAgentSessionFilePath(sessionId) {
   }
   const rel = await resolveSessionRelativePathFromIndex(sessionId);
   if (rel) {
-    const full = path33.join(appDir, rel);
+    const full = path34.join(appDir, rel);
     try {
       await fs30.access(full);
       return full;
@@ -3067,16 +3067,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 = path33.join(sessionsRoot, y, mo, d);
+  const datedDir = path34.join(sessionsRoot, y, mo, d);
   await fs30.mkdir(datedDir, { recursive: true });
-  const sessionFile = path33.join(datedDir, `${sessionId}.json`);
+  const sessionFile = path34.join(datedDir, `${sessionId}.json`);
   const newSessionData = {
     session_id: sessionId,
     created_at: now2.toISOString(),
     conversation_history: []
   };
   await fs30.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
-  const relToApp = path33.relative(getPreferredAppDir(), sessionFile);
+  const relToApp = path34.relative(getPreferredAppDir(), sessionFile);
   await appendAgentSessionPath(sessionId, relToApp);
   const emptyMemory = {
     historyAnchor: null,
@@ -3088,7 +3088,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path33.dirname(sessionFile);
+      const dir = path34.dirname(sessionFile);
       await fs30.mkdir(dir, { recursive: true });
     } catch {
     }
@@ -3104,7 +3104,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path33.basename(sessionFile, ".json");
+      const sessionId = path34.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3129,12 +3129,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     try {
       await fs30.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
-      const sessionId = sessionData.session_id ?? path33.basename(sessionFile, ".json");
+      const sessionId = sessionData.session_id ?? path34.basename(sessionFile, ".json");
       const updatedAt = sessionData.last_updated ?? (/* @__PURE__ */ new Date()).toISOString();
       const createdAt = sessionData.created_at ?? updatedAt;
       let relToApp;
       try {
-        relToApp = path33.relative(getPreferredAppDir(), sessionFile);
+        relToApp = path34.relative(getPreferredAppDir(), sessionFile);
       } catch {
         relToApp = sessionFile;
       }
@@ -3205,7 +3205,7 @@ __export(exportConversation_exports, {
   resolveExportOutputPath: () => resolveExportOutputPath
 });
 import { promises as fs48 } from "fs";
-import path54 from "path";
+import path55 from "path";
 function extractTextParts2(content) {
   if (typeof content === "string") {
     const trimmed = content.trim();
@@ -3363,12 +3363,12 @@ function resolveExportOutputPath(sessionId, options) {
   const { outputPath, defaultExportDir } = options ?? {};
   if (outputPath?.trim()) {
     const raw = outputPath.trim();
-    return path54.isAbsolute(raw) ? raw : path54.resolve(process.cwd(), raw);
+    return path55.isAbsolute(raw) ? raw : path55.resolve(process.cwd(), raw);
   }
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const safeId = sessionId.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 48) || "session";
   const baseDir = defaultExportDir ?? getSandboxPolicy().workspaceRoot;
-  return path54.join(baseDir, `bluma-export-${safeId}-${stamp}.md`);
+  return path55.join(baseDir, `bluma-export-${safeId}-${stamp}.md`);
 }
 async function resolveHistory(sessionId, fallbackHistory) {
   const loaded2 = await loadSession(sessionId);
@@ -3390,7 +3390,7 @@ async function exportConversationToFile(options) {
     }
     const markdown = formatConversationMarkdown(sessionId, history);
     const filePath = resolveExportOutputPath(sessionId, { outputPath, defaultExportDir });
-    await fs48.mkdir(path54.dirname(filePath), { recursive: true });
+    await fs48.mkdir(path55.dirname(filePath), { recursive: true });
     await fs48.writeFile(filePath, markdown, "utf-8");
     return {
       success: true,
@@ -3916,11 +3916,11 @@ var NodeFsOperations = {
       if (fd) fs.closeSync(fd);
     }
   },
-  appendFileSync(path59, data, options) {
-    const _ = slowLogging`fs.appendFileSync(${path59}, ${data.length} chars)`;
+  appendFileSync(path60, data, options) {
+    const _ = slowLogging`fs.appendFileSync(${path60}, ${data.length} chars)`;
     if (options?.mode !== void 0) {
       try {
-        const fd = fs.openSync(path59, "ax", options.mode);
+        const fd = fs.openSync(path60, "ax", options.mode);
         try {
           fs.appendFileSync(fd, data);
         } finally {
@@ -3931,35 +3931,35 @@ var NodeFsOperations = {
         if (getErrnoCode(e) !== "EEXIST") throw e;
       }
     }
-    fs.appendFileSync(path59, data);
+    fs.appendFileSync(path60, data);
   },
   copyFileSync(src, dest) {
     const _ = slowLogging`fs.copyFileSync(${src} → ${dest})`;
     fs.copyFileSync(src, dest);
   },
-  unlinkSync(path59) {
-    const _ = slowLogging`fs.unlinkSync(${path59})`;
-    fs.unlinkSync(path59);
+  unlinkSync(path60) {
+    const _ = slowLogging`fs.unlinkSync(${path60})`;
+    fs.unlinkSync(path60);
   },
   renameSync(oldPath, newPath) {
     const _ = slowLogging`fs.renameSync(${oldPath} → ${newPath})`;
     fs.renameSync(oldPath, newPath);
   },
-  linkSync(target, path59) {
-    const _ = slowLogging`fs.linkSync(${target} → ${path59})`;
-    fs.linkSync(target, path59);
+  linkSync(target, path60) {
+    const _ = slowLogging`fs.linkSync(${target} → ${path60})`;
+    fs.linkSync(target, path60);
   },
-  symlinkSync(target, path59, type) {
-    const _ = slowLogging`fs.symlinkSync(${target} → ${path59})`;
-    fs.symlinkSync(target, path59, type);
+  symlinkSync(target, path60, type) {
+    const _ = slowLogging`fs.symlinkSync(${target} → ${path60})`;
+    fs.symlinkSync(target, path60, type);
   },
-  readlinkSync(path59) {
-    const _ = slowLogging`fs.readlinkSync(${path59})`;
-    return fs.readlinkSync(path59);
+  readlinkSync(path60) {
+    const _ = slowLogging`fs.readlinkSync(${path60})`;
+    return fs.readlinkSync(path60);
   },
-  realpathSync(path59) {
-    const _ = slowLogging`fs.realpathSync(${path59})`;
-    return fs.realpathSync(path59).normalize("NFC");
+  realpathSync(path60) {
+    const _ = slowLogging`fs.realpathSync(${path60})`;
+    return fs.realpathSync(path60).normalize("NFC");
   },
   mkdirSync(dirPath, options) {
     const _ = slowLogging`fs.mkdirSync(${dirPath})`;
@@ -3992,12 +3992,12 @@ var NodeFsOperations = {
     const _ = slowLogging`fs.rmdirSync(${dirPath})`;
     fs.rmdirSync(dirPath);
   },
-  rmSync(path59, options) {
-    const _ = slowLogging`fs.rmSync(${path59})`;
-    fs.rmSync(path59, options);
+  rmSync(path60, options) {
+    const _ = slowLogging`fs.rmSync(${path60})`;
+    fs.rmSync(path60, options);
   },
-  createWriteStream(path59) {
-    return fs.createWriteStream(path59);
+  createWriteStream(path60) {
+    return fs.createWriteStream(path60);
   },
   async readFileBytes(fsPath, maxBytes) {
     if (maxBytes === void 0) {
@@ -4104,12 +4104,12 @@ function shouldLogDebugMessage(message2) {
 var hasFormattedOutput = false;
 var debugWriter = null;
 var pendingWrite = Promise.resolve();
-async function appendAsync(needMkdir, dir, path59, content) {
+async function appendAsync(needMkdir, dir, path60, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {
     });
   }
-  await appendFile(path59, content);
+  await appendFile(path60, content);
   void updateLatestDebugLogSymlink();
 }
 function noop() {
@@ -4119,8 +4119,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path59 = getDebugLogPath();
-        const dir = dirname(path59);
+        const path60 = getDebugLogPath();
+        const dir = dirname(path60);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -4130,11 +4130,11 @@ function getDebugWriter() {
             } catch {
             }
           }
-          getFsImplementation().appendFileSync(path59, content);
+          getFsImplementation().appendFileSync(path60, content);
           void updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path59, content)).catch(noop);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path60, content)).catch(noop);
       },
       flushIntervalMs: 1e3,
       maxBufferSize: 100,
@@ -10321,8 +10321,8 @@ import codeExcerpt from "code-excerpt";
 import { readFileSync as readFileSync2 } from "fs";
 import StackUtils from "stack-utils";
 import { jsx as jsx6, jsxs } from "react/jsx-runtime";
-var cleanupPath = (path59) => {
-  return path59?.replace(`file://${process.cwd()}/`, "");
+var cleanupPath = (path60) => {
+  return path60?.replace(`file://${process.cwd()}/`, "");
 };
 var stackUtils;
 function getStackUtils() {
@@ -14300,7 +14300,7 @@ var getInstance = (stdout, createInstance) => {
 // src/main.ts
 import { EventEmitter as EventEmitter7 } from "events";
 import fs52 from "fs";
-import path58 from "path";
+import path59 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
@@ -14979,12 +14979,12 @@ function cancelSlashSubmenu() {
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path48 from "path";
+import path49 from "path";
 import os30 from "os";
 
 // src/app/agent/tool_invoker.ts
 import { promises as fs26 } from "fs";
-import path29 from "path";
+import path30 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/app/agent/tools/EditTool/EditTool.ts
@@ -20113,7 +20113,7 @@ async function createNextApp(args) {
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 init_sandbox_policy();
 import { promises as fs25 } from "fs";
-import path28 from "path";
+import path29 from "path";
 
 // src/app/agent/tools/DeployAppTool/createDeployProjectZip.ts
 import { lstat, readdir, readFile as readFile2, writeFile } from "fs/promises";
@@ -20211,6 +20211,91 @@ async function createDeployProjectZip(projectDir, zipPath) {
   return zipPath;
 }
 
+// src/app/agent/tools/DeployAppTool/nextDeployConfig.ts
+import { access, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path28 from "path";
+var FACTORAI_NEXT_CONFIG_JS = `/** @type {import('next').NextConfig} */
+module.exports = {
+  output: "standalone",
+  reactStrictMode: true,
+};
+`;
+var FACTORAI_NEXT_CONFIG_JSON = `${JSON.stringify(
+  {
+    output: "standalone",
+    reactStrictMode: true
+  },
+  null,
+  2
+)}
+`;
+var STANDALONE_RE = /output\s*:\s*["']standalone["']/;
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasStandaloneInJs(source) {
+  return STANDALONE_RE.test(source);
+}
+function hasStandaloneInJson(source) {
+  try {
+    const parsed = JSON.parse(source);
+    return parsed.output === "standalone";
+  } catch {
+    return false;
+  }
+}
+async function ensureNextStandaloneConfig(projectDir) {
+  const warnings = [];
+  const jsPath = path28.join(projectDir, "next.config.js");
+  const jsonPath = path28.join(projectDir, "next.config.json");
+  const mjsPath = path28.join(projectDir, "next.config.mjs");
+  const hasJs = await fileExists(jsPath);
+  const hasJson = await fileExists(jsonPath);
+  const hasMjs = await fileExists(mjsPath);
+  if (hasMjs) {
+    const mjs = await readFile3(mjsPath, "utf-8");
+    if (!hasStandaloneInJs(mjs)) {
+      warnings.push('next.config.mjs missing output: "standalone" \u2014 update manually for FactorAI deploy');
+      return { ok: false, warnings };
+    }
+    return { ok: true, warnings };
+  }
+  if (hasJs) {
+    const js = await readFile3(jsPath, "utf-8");
+    const directExport = /module\.exports\s*=\s*\{/.test(js) && hasStandaloneInJs(js);
+    if (directExport) {
+      return { ok: true, warnings };
+    }
+    if (hasStandaloneInJs(js)) {
+      await writeFile2(jsPath, FACTORAI_NEXT_CONFIG_JS, "utf-8");
+      warnings.push(
+        "next.config.js reescrito em formato compat\xEDvel com o deploy FactorAI (module.exports direto)"
+      );
+      return { ok: true, warnings };
+    }
+    await writeFile2(jsPath, FACTORAI_NEXT_CONFIG_JS, "utf-8");
+    warnings.push('next.config.js atualizado com output: "standalone"');
+    return { ok: true, warnings };
+  }
+  if (hasJson) {
+    const json = await readFile3(jsonPath, "utf-8");
+    if (hasStandaloneInJson(json)) {
+      return { ok: true, warnings };
+    }
+    await writeFile2(jsonPath, FACTORAI_NEXT_CONFIG_JSON, "utf-8");
+    warnings.push('next.config.json atualizado com output: "standalone"');
+    return { ok: true, warnings };
+  }
+  await writeFile2(jsonPath, FACTORAI_NEXT_CONFIG_JSON, "utf-8");
+  warnings.push('Criado next.config.json com output: "standalone"');
+  return { ok: true, warnings };
+}
+
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
   const deployUrl = `${severinoUrl.replace(/\/$/, "")}/api/v1/deploy`;
@@ -20219,7 +20304,7 @@ async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
   form.append(
     "file",
     new Blob([zipBytes], { type: "application/zip" }),
-    path28.basename(zipPath)
+    path29.basename(zipPath)
   );
   if (name) form.append("name", name);
   if (appId) form.append("appId", appId);
@@ -20328,7 +20413,7 @@ function buildFactorAiManifest(appContext, deployResult, appName) {
 }
 async function writeFactorAiManifest(projectDir, appContext, deployResult, appName) {
   const manifest = buildFactorAiManifest(appContext, deployResult, appName);
-  const manifestPath = path28.join(projectDir, "factorai.sh.json");
+  const manifestPath = path29.join(projectDir, "factorai.sh.json");
   await fs25.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   return manifest;
@@ -20356,7 +20441,7 @@ async function deployApp(args) {
         error: `Project directory not found: ${resolvedProjectDir}`
       };
     }
-    const packageJsonPath = path28.join(resolvedProjectDir, "package.json");
+    const packageJsonPath = path29.join(resolvedProjectDir, "package.json");
     try {
       await fs25.access(packageJsonPath);
     } catch {
@@ -20374,10 +20459,20 @@ async function deployApp(args) {
         error: "Not a Next.js project: next not found in dependencies"
       };
     }
-    const appName = name || packageJson.name || path28.basename(resolvedProjectDir);
-    const tempDir = path28.join(resolvedProjectDir, ".tmp");
+    const standaloneCheck = await ensureNextStandaloneConfig(resolvedProjectDir);
+    if (!standaloneCheck.ok) {
+      return {
+        success: false,
+        error: `Next.js config invalid for FactorAI deploy: ${standaloneCheck.warnings.join("; ")}`
+      };
+    }
+    for (const w of standaloneCheck.warnings) {
+      console.warn(`[deploy-app] ${w}`);
+    }
+    const appName = name || packageJson.name || path29.basename(resolvedProjectDir);
+    const tempDir = path29.join(resolvedProjectDir, ".tmp");
     await fs25.mkdir(tempDir, { recursive: true });
-    const zipPath = path28.join(tempDir, `${appName}-${Date.now()}.zip`);
+    const zipPath = path29.join(tempDir, `${appName}-${Date.now()}.zip`);
     console.log(`[deploy-app] Creating ZIP: ${zipPath}`);
     await createDeployProjectZip(resolvedProjectDir, zipPath);
     const zipStats = await fs25.stat(zipPath);
@@ -20410,7 +20505,7 @@ async function deployApp(args) {
           appName
         );
         deployResult.factoraiManifest = manifest;
-        deployResult.factoraiManifestPath = path28.join(resolvedProjectDir, "factorai.sh.json");
+        deployResult.factoraiManifestPath = path29.join(resolvedProjectDir, "factorai.sh.json");
       }
       console.log(`[deploy-app] Deploy iniciado: ${deployResult.appId}`);
     }
@@ -21491,8 +21586,8 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const currentFilePath = fileURLToPath2(import.meta.url);
-      const currentDirPath = path29.dirname(currentFilePath);
-      const configPath = path29.resolve(currentDirPath, "config", "native_tools.json");
+      const currentDirPath = path30.dirname(currentFilePath);
+      const configPath = path30.resolve(currentDirPath, "config", "native_tools.json");
       const fileContent = await fs26.readFile(configPath, "utf-8");
       const config3 = JSON.parse(fileContent);
       this.toolDefinitions = applyMetadataToToolDefinitions(config3.nativeTools);
@@ -21541,7 +21636,7 @@ var ToolInvoker = class {
 
 // src/app/agent/tools/mcp/mcp_client.ts
 import { promises as fs27 } from "fs";
-import path30 from "path";
+import path31 from "path";
 import os19 from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -21569,9 +21664,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath3(import.meta.url);
-    const __dirname2 = path30.dirname(__filename);
-    const defaultConfigPath = path30.resolve(__dirname2, "config", "bluma-mcp.json");
-    const userConfigPath = path30.join(os19.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname2 = path31.dirname(__filename);
+    const defaultConfigPath = path31.resolve(__dirname2, "config", "bluma-mcp.json");
+    const userConfigPath = path31.join(os19.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -21818,19 +21913,19 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 
 // src/app/agent/bluma/core/bluma.ts
 init_session_manager();
-import path45 from "path";
+import path46 from "path";
 import fs40 from "fs";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os23 from "os";
 import fs36 from "fs";
-import path39 from "path";
+import path40 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
 import fs31 from "fs";
-import path34 from "path";
+import path35 from "path";
 import os20 from "os";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var SkillLoader = class _SkillLoader {
@@ -21840,8 +21935,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path34.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path34.join(os20.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path35.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path35.join(os20.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -21850,32 +21945,32 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path34.join(process.cwd(), "dist", "config", "skills");
+      return path35.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path34.resolve(p);
+      const abs = path35.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path34.dirname(fileURLToPath4(import.meta.url));
-      push(path34.join(bundleDir, "config", "skills"));
+      const bundleDir = path35.dirname(fileURLToPath4(import.meta.url));
+      push(path35.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path34.isAbsolute(argv1) && fs31.existsSync(argv1)) {
+        if (path35.isAbsolute(argv1) && fs31.existsSync(argv1)) {
           resolved = fs31.realpathSync(argv1);
-        } else if (!path34.isAbsolute(argv1)) {
-          resolved = path34.resolve(process.cwd(), argv1);
+        } else if (!path35.isAbsolute(argv1)) {
+          resolved = path35.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path34.dirname(resolved);
-        argvBundled = path34.join(scriptDir, "config", "skills");
+        const scriptDir = path35.dirname(resolved);
+        argvBundled = path35.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
@@ -21886,12 +21981,12 @@ var SkillLoader = class _SkillLoader {
       }
     }
     try {
-      return path34.join(path34.dirname(fileURLToPath4(import.meta.url)), "config", "skills");
+      return path35.join(path35.dirname(fileURLToPath4(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path34.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path35.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -21920,8 +22015,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path34.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path34.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path35.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path35.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -21932,9 +22027,9 @@ var SkillLoader = class _SkillLoader {
     if (!fs31.existsSync(dir)) return [];
     try {
       return fs31.readdirSync(dir).filter((d) => {
-        const fullPath = path34.join(dir, d);
-        return fs31.statSync(fullPath).isDirectory() && fs31.existsSync(path34.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path34.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+        const fullPath = path35.join(dir, d);
+        return fs31.statSync(fullPath).isDirectory() && fs31.existsSync(path35.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path35.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
@@ -21964,9 +22059,9 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path34.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path34.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path34.join(this.globalSkillsDir, name, "SKILL.md");
+    const bundledPath = path35.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path35.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path35.join(this.globalSkillsDir, name, "SKILL.md");
     const existsBundled = fs31.existsSync(bundledPath);
     const existsProject = fs31.existsSync(projectPath);
     const existsGlobal = fs31.existsSync(globalPath);
@@ -22010,7 +22105,7 @@ var SkillLoader = class _SkillLoader {
     try {
       const raw = fs31.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path34.dirname(skillPath);
+      const skillDir = path35.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -22019,8 +22114,8 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path34.join(skillDir, "references")),
-        scripts: this.scanAssets(path34.join(skillDir, "scripts"))
+        references: this.scanAssets(path35.join(skillDir, "references")),
+        scripts: this.scanAssets(path35.join(skillDir, "scripts"))
       };
     } catch {
       return null;
@@ -22030,11 +22125,11 @@ var SkillLoader = class _SkillLoader {
     if (!fs31.existsSync(dir)) return [];
     try {
       return fs31.readdirSync(dir).filter((f) => {
-        const fp = path34.join(dir, f);
+        const fp = path35.join(dir, f);
         return fs31.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path34.resolve(dir, f)
+        path: path35.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -22091,9 +22186,9 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path34.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path34.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path34.join(this.globalSkillsDir, name, "SKILL.md");
+    const bundledPath = path35.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path35.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path35.join(this.globalSkillsDir, name, "SKILL.md");
     return fs31.existsSync(bundledPath) || fs31.existsSync(projectPath) || fs31.existsSync(globalPath);
   }
   /**
@@ -22127,12 +22222,12 @@ var SkillLoader = class _SkillLoader {
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
 import fs33 from "fs";
-import path36 from "path";
+import path37 from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/app/agent/utils/blumamd.ts
 import fs32 from "fs";
-import path35 from "path";
+import path36 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.";
@@ -22262,12 +22357,12 @@ var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 function expandIncludePath(includePath, baseDir) {
   const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
   if (cleanPath.startsWith("~")) {
-    return path35.join(os21.homedir(), cleanPath.slice(1));
+    return path36.join(os21.homedir(), cleanPath.slice(1));
   }
-  if (path35.isAbsolute(cleanPath)) {
+  if (path36.isAbsolute(cleanPath)) {
     return cleanPath;
   }
-  return path35.resolve(baseDir, cleanPath);
+  return path36.resolve(baseDir, cleanPath);
 }
 function processIncludes(content, baseDir, processedFiles) {
   const lines = content.split("\n");
@@ -22276,12 +22371,12 @@ function processIncludes(content, baseDir, processedFiles) {
     const includeMatch = line.match(/^@\s*([^\s]+)/);
     if (includeMatch) {
       const includePath = expandIncludePath(includeMatch[1], baseDir);
-      const normalizedPath = path35.normalize(includePath);
+      const normalizedPath = path36.normalize(includePath);
       if (processedFiles.has(normalizedPath)) {
         result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
         continue;
       }
-      const ext = path35.extname(includePath).toLowerCase();
+      const ext = path36.extname(includePath).toLowerCase();
       if (!TEXT_FILE_EXTENSIONS.has(ext)) {
         result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
         continue;
@@ -22289,7 +22384,7 @@ function processIncludes(content, baseDir, processedFiles) {
       try {
         const includedContent = fs32.readFileSync(includePath, "utf-8");
         processedFiles.add(normalizedPath);
-        const processedContent = processIncludes(includedContent, path35.dirname(includePath), processedFiles);
+        const processedContent = processIncludes(includedContent, path36.dirname(includePath), processedFiles);
         result.push(`
 <!-- BEGIN INCLUDE ${includeMatch[1]} -->
 `);
@@ -22336,8 +22431,8 @@ function parseFrontmatterPaths(paths2) {
 function readMemoryFile(filePath, type, includeBasePath) {
   try {
     const rawContent = fs32.readFileSync(filePath, "utf-8");
-    const baseDir = includeBasePath || path35.dirname(filePath);
-    const processedFiles = /* @__PURE__ */ new Set([path35.normalize(filePath)]);
+    const baseDir = includeBasePath || path36.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path36.normalize(filePath)]);
     const { frontmatter, content: withoutFrontmatter } = parseFrontmatter(rawContent);
     const globs = parseFrontmatterPaths(frontmatter.paths);
     const processedContent = processIncludes(withoutFrontmatter, baseDir, processedFiles);
@@ -22359,15 +22454,15 @@ function readMemoryFile(filePath, type, includeBasePath) {
 }
 function findGitRoot(startDir) {
   let current = startDir;
-  while (current !== path35.dirname(current)) {
-    const gitPath = path35.join(current, ".git");
+  while (current !== path36.dirname(current)) {
+    const gitPath = path36.join(current, ".git");
     try {
       if (fs32.existsSync(gitPath)) {
         return current;
       }
     } catch {
     }
-    current = path35.dirname(current);
+    current = path36.dirname(current);
   }
   return null;
 }
@@ -22398,11 +22493,11 @@ function processRulesDirectory(rulesDir, type, processedPaths, conditionalRule =
   try {
     const entries = fs32.readdirSync(rulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path35.join(rulesDir, entry.name);
+      const entryPath = path36.join(rulesDir, entry.name);
       if (entry.isDirectory()) {
         result.push(...processRulesDirectory(entryPath, type, processedPaths, conditionalRule));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const normalizedPath = path35.normalize(entryPath);
+        const normalizedPath = path36.normalize(entryPath);
         if (processedPaths.has(normalizedPath)) {
           continue;
         }
@@ -22438,13 +22533,13 @@ function loadManagedMemory() {
 function loadUserMemory() {
   const files = [];
   const homeDir = os21.homedir();
-  const userBlumaDir = path35.join(homeDir, ".bluma");
-  const userBlumaMd = path35.join(userBlumaDir, "BLUMA.md");
+  const userBlumaDir = path36.join(homeDir, ".bluma");
+  const userBlumaMd = path36.join(userBlumaDir, "BLUMA.md");
   const userFile = readMemoryFile(userBlumaMd, "User");
   if (userFile && userFile.content.trim()) {
     files.push(userFile);
   }
-  const userRulesDir = path35.join(userBlumaDir, "rules");
+  const userRulesDir = path36.join(userBlumaDir, "rules");
   const processedPaths = /* @__PURE__ */ new Set();
   files.push(...processRulesDirectory(userRulesDir, "User", processedPaths, false));
   return files;
@@ -22456,10 +22551,10 @@ function loadProjectMemory(cwd2) {
   let currentDir = cwd2;
   const MAX_TRAVERSAL_DEPTH = 20;
   let depth = 0;
-  const normalizedGitRoot = path35.resolve(gitRoot);
-  while (currentDir !== path35.dirname(currentDir) && path35.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
+  const normalizedGitRoot = path36.resolve(gitRoot);
+  while (currentDir !== path36.dirname(currentDir) && path36.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
     dirs.push(currentDir);
-    currentDir = path35.dirname(currentDir);
+    currentDir = path36.dirname(currentDir);
     depth++;
   }
   if (!dirs.includes(gitRoot)) {
@@ -22467,7 +22562,7 @@ function loadProjectMemory(cwd2) {
   }
   const processedPaths = /* @__PURE__ */ new Set();
   for (const dir of dirs.reverse()) {
-    const projectBlumaMd = path35.join(dir, "BLUMA.md");
+    const projectBlumaMd = path36.join(dir, "BLUMA.md");
     if (!processedPaths.has(projectBlumaMd)) {
       processedPaths.add(projectBlumaMd);
       const projectFile = readMemoryFile(projectBlumaMd, "Project");
@@ -22475,7 +22570,7 @@ function loadProjectMemory(cwd2) {
         files.push(projectFile);
       }
     }
-    const blumaDirBlumaMd = path35.join(dir, ".bluma", "BLUMA.md");
+    const blumaDirBlumaMd = path36.join(dir, ".bluma", "BLUMA.md");
     if (!processedPaths.has(blumaDirBlumaMd)) {
       processedPaths.add(blumaDirBlumaMd);
       const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "Project");
@@ -22483,10 +22578,10 @@ function loadProjectMemory(cwd2) {
         files.push(blumaDirFile);
       }
     }
-    const rulesDir = path35.join(dir, ".bluma", "rules");
+    const rulesDir = path36.join(dir, ".bluma", "rules");
     files.push(...processRulesDirectory(rulesDir, "Project", processedPaths, false));
   }
-  const localBlumaMd = path35.join(cwd2, "BLUMA.local.md");
+  const localBlumaMd = path36.join(cwd2, "BLUMA.local.md");
   if (!processedPaths.has(localBlumaMd)) {
     processedPaths.add(localBlumaMd);
     const localFile = readMemoryFile(localBlumaMd, "Local");
@@ -22587,7 +22682,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd2) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path36.join(cwd2, name), LIMITS.readme);
+    const c = safeReadFile(path37.join(cwd2, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -22595,14 +22690,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd2) {
   const paths2 = [
-    path36.join(cwd2, "BluMa.md"),
-    path36.join(cwd2, "BLUMA.md"),
-    path36.join(cwd2, ".bluma", "BluMa.md")
+    path37.join(cwd2, "BluMa.md"),
+    path37.join(cwd2, "BLUMA.md"),
+    path37.join(cwd2, ".bluma", "BluMa.md")
   ];
   for (const p of paths2) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path36.relative(cwd2, p) || p;
+      const rel = path37.relative(cwd2, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -22610,7 +22705,7 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd2) {
-  const p = path36.join(cwd2, "package.json");
+  const p = path37.join(cwd2, "package.json");
   try {
     if (!fs33.existsSync(p)) return null;
     const pkg = JSON.parse(fs33.readFileSync(p, "utf8"));
@@ -22704,7 +22799,7 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path36.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path37.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -22722,15 +22817,15 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path36.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path37.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path36.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path37.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path36.join(cwd2, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path37.join(cwd2, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -22766,14 +22861,14 @@ function buildWorkspaceSnapshot(cwd2) {
   } else {
     parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
   }
-  const tsconfig = safeReadFile(path36.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
+  const tsconfig = safeReadFile(path37.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(path36.join(cwd2, name), LIMITS.dockerfile);
+    const df = safeReadFile(path37.join(cwd2, name), LIMITS.dockerfile);
     if (df) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22783,7 +22878,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const dc = safeReadFile(path36.join(cwd2, name), LIMITS.dockerfile);
+    const dc = safeReadFile(path37.join(cwd2, name), LIMITS.dockerfile);
     if (dc) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22798,7 +22893,7 @@ function buildWorkspaceSnapshot(cwd2) {
     ".circleci/config.yml",
     "Jenkinsfile"
   ]) {
-    const ciFile = path36.join(cwd2, ciPath);
+    const ciFile = path37.join(cwd2, ciPath);
     if (fs33.existsSync(ciFile)) {
       const st = fs33.statSync(ciFile);
       if (st.isDirectory()) {
@@ -22814,7 +22909,7 @@ function buildWorkspaceSnapshot(cwd2) {
       } else {
         const ci = safeReadFile(ciFile, LIMITS.ciConfig);
         if (ci) {
-          parts.push(`### CI config (${path36.basename(ciPath)})
+          parts.push(`### CI config (${path37.basename(ciPath)})
 `);
           parts.push(ci);
           parts.push("\n");
@@ -22823,7 +22918,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const depFile of ["requirements.txt", "Pipfile", "poetry.lock", "Gemfile", "go.sum", "Cargo.lock"]) {
-    const depPath = path36.join(cwd2, depFile);
+    const depPath = path37.join(cwd2, depFile);
     if (fs33.existsSync(depPath)) {
       const depContent = safeReadFile(depPath, 1500);
       if (depContent) {
@@ -22837,7 +22932,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
-    const envPath = path36.join(cwd2, envFile);
+    const envPath = path37.join(cwd2, envFile);
     if (fs33.existsSync(envPath)) {
       try {
         const raw = fs33.readFileSync(envPath, "utf-8");
@@ -22865,13 +22960,13 @@ init_runtime_config();
 init_sandbox_policy();
 import fs34 from "fs";
 import os22 from "os";
-import path37 from "path";
+import path38 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path37.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path38.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path37.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
+  return path38.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -22897,8 +22992,8 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path37.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path37.join(pluginDir, "plugin.json")
+    path38.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path38.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
     if (fs34.existsSync(candidate)) {
@@ -22912,7 +23007,7 @@ function listFromDir(baseDir, source) {
     return [];
   }
   return fs34.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path37.join(baseDir, entry.name);
+    const pluginDir = path38.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -23358,7 +23453,7 @@ function buildModelInfoSection(modelId) {
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
 import fs35 from "fs";
-import path38 from "path";
+import path39 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -23369,7 +23464,7 @@ var cache3 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path38.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path39.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -23415,7 +23510,7 @@ function ensureLoaded2() {
 }
 function persist2(state2) {
   const statePath = getStatePath();
-  fs35.mkdirSync(path38.dirname(statePath), { recursive: true });
+  fs35.mkdirSync(path39.dirname(statePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   fs35.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
   cache3 = state2;
@@ -23679,15 +23774,15 @@ init_memdir();
 
 // src/app/agent/memory/session_memory_context.ts
 init_session_memory_paths();
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 async function loadSessionMemoryForPrompt(sessionId, cwd2 = process.cwd()) {
   if (!sessionId?.trim()) return "";
-  const path59 = getSessionMemoryPath(sessionId, cwd2);
+  const path60 = getSessionMemoryPath(sessionId, cwd2);
   try {
-    const content = await readFile3(path59, "utf-8");
+    const content = await readFile4(path60, "utf-8");
     if (!content.trim()) return "";
     return `<session_memory>
-Notes for this conversation (${path59}):
+Notes for this conversation (${path60}):
 
 ${content.trim()}
 </session_memory>`;
@@ -23697,11 +23792,11 @@ ${content.trim()}
 }
 async function initSessionMemoryFile(sessionId, cwd2 = process.cwd()) {
   await ensureSessionMemoryDir(sessionId, cwd2);
-  const path59 = getSessionMemoryPath(sessionId, cwd2);
+  const path60 = getSessionMemoryPath(sessionId, cwd2);
   try {
-    await readFile3(path59, "utf-8");
+    await readFile4(path60, "utf-8");
   } catch {
-    await writeFile2(path59, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
+    await writeFile3(path60, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
 `, "utf-8");
   }
 }
@@ -23783,7 +23878,7 @@ Use \`factorai.sh.redeploy_app({ appId })\` only when sources on the server are
 
 ## Deploy constraints (first deploy)
 
-- \`next.config.js\` must keep \`output: 'standalone'\` (included in scaffold).
+- \`next.config.js\` must use direct \`module.exports = { output: "standalone", ... }\` (FactorAI deployer cannot parse \`const nextConfig\` indirection).
 - 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).
 
@@ -23834,17 +23929,17 @@ function getGitBranch(dir) {
   }
 }
 function getPackageManager(dir) {
-  if (fs36.existsSync(path39.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs36.existsSync(path39.join(dir, "yarn.lock"))) return "yarn";
-  if (fs36.existsSync(path39.join(dir, "bun.lockb"))) return "bun";
-  if (fs36.existsSync(path39.join(dir, "package-lock.json"))) return "npm";
+  if (fs36.existsSync(path40.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs36.existsSync(path40.join(dir, "yarn.lock"))) return "yarn";
+  if (fs36.existsSync(path40.join(dir, "bun.lockb"))) return "bun";
+  if (fs36.existsSync(path40.join(dir, "package-lock.json"))) return "npm";
   return "unknown";
 }
 function getProjectType(dir) {
   try {
     const files = fs36.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs36.readFileSync(path39.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs36.readFileSync(path40.join(dir, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.next) return "Next.js";
       if (deps.react) return "React";
@@ -23864,7 +23959,7 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path39.join(dir, "package.json");
+    const pkgPath = path40.join(dir, "package.json");
     if (fs36.existsSync(pkgPath)) {
       const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -23875,7 +23970,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs36.existsSync(path39.join(dir, "pytest.ini")) || fs36.existsSync(path39.join(dir, "conftest.py"))) return "pytest";
+    if (fs36.existsSync(path40.join(dir, "pytest.ini")) || fs36.existsSync(path40.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -23883,7 +23978,7 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path39.join(dir, "package.json");
+    const pkgPath = path40.join(dir, "package.json");
     if (fs36.existsSync(pkgPath)) {
       const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return "npm test";
@@ -23900,7 +23995,7 @@ function getTestCommand(dir) {
 }
 function isGitRepo(dir) {
   try {
-    const p = path39.join(dir, ".git");
+    const p = path40.join(dir, ".git");
     return fs36.existsSync(p) && fs36.lstatSync(p).isDirectory();
   } catch {
     return false;
@@ -25337,7 +25432,7 @@ var LLMService = class {
 // src/app/agent/utils/user_message_images.ts
 import fs37 from "fs";
 import os25 from "os";
-import path40 from "path";
+import path41 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
 var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
@@ -25353,22 +25448,22 @@ var MIME = {
 function expandUserPath(p) {
   const t = p.trim();
   if (t.startsWith("~")) {
-    return path40.join(os25.homedir(), t.slice(1).replace(/^\//, ""));
+    return path41.join(os25.homedir(), t.slice(1).replace(/^\//, ""));
   }
   return t;
 }
 function isPathAllowed(absResolved, cwd2) {
-  const resolved = path40.normalize(path40.resolve(absResolved));
-  const cwdR = path40.normalize(path40.resolve(cwd2));
-  const homeR = path40.normalize(path40.resolve(os25.homedir()));
-  const tmpR = path40.normalize(path40.resolve(os25.tmpdir()));
-  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path40.sep);
-  const underHome = resolved === homeR || resolved.startsWith(homeR + path40.sep);
-  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path40.sep);
+  const resolved = path41.normalize(path41.resolve(absResolved));
+  const cwdR = path41.normalize(path41.resolve(cwd2));
+  const homeR = path41.normalize(path41.resolve(os25.homedir()));
+  const tmpR = path41.normalize(path41.resolve(os25.tmpdir()));
+  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path41.sep);
+  const underHome = resolved === homeR || resolved.startsWith(homeR + path41.sep);
+  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path41.sep);
   return underCwd || underHome || underTmp;
 }
 function mimeFor(abs) {
-  const ext = path40.extname(abs).toLowerCase();
+  const ext = path41.extname(abs).toLowerCase();
   return MIME[ext] || "application/octet-stream";
 }
 var IMAGE_EXT_SRC = String.raw`(?:png|jpe?g|gif|webp|bmp)`;
@@ -25412,7 +25507,7 @@ function collectImagePathStrings(raw) {
 }
 function resolveImagePath(candidate, cwd2) {
   const expanded = expandUserPath(candidate);
-  const abs = path40.isAbsolute(expanded) ? path40.normalize(expanded) : path40.normalize(path40.resolve(cwd2, expanded));
+  const abs = path41.isAbsolute(expanded) ? path41.normalize(expanded) : path41.normalize(path41.resolve(cwd2, expanded));
   if (!isPathAllowed(abs, cwd2)) return null;
   try {
     if (!fs37.existsSync(abs) || !fs37.statSync(abs).isFile()) return null;
@@ -25435,7 +25530,7 @@ function trySingleLineFileUriOrBareImagePath(line, cwd2) {
   if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
     s = s.slice(1, -1).trim();
   }
-  if (!IMAGE_EXT.test(path40.extname(s))) return null;
+  if (!IMAGE_EXT.test(path41.extname(s))) return null;
   const abs = resolveImagePath(s, cwd2);
   if (!abs) return null;
   try {
@@ -25538,7 +25633,7 @@ function buildUserMessageContent(raw, cwd2) {
 init_sandbox_policy();
 init_runtime_config();
 init_permission_rules();
-import path41 from "path";
+import path42 from "path";
 var LOCAL_EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["edit_tool", "file_write", "notebook_edit"]);
 function getToolPermissionLayer(metadata) {
   if (metadata.riskLevel === "safe") return "read";
@@ -25553,11 +25648,11 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (!filePath) {
     return { allowed: false, reason: "No file path provided for permission check." };
   }
-  const resolvedPath = path41.resolve(filePath);
+  const resolvedPath = path42.resolve(filePath);
   if (!isPathInsideWorkspace(resolvedPath, policy)) {
     return { allowed: false, reason: `File path "${filePath}" is outside workspace root.` };
   }
-  const relativePath = path41.relative(policy.workspaceRoot, resolvedPath);
+  const relativePath = path42.relative(policy.workspaceRoot, resolvedPath);
   const toolPattern = `${toolName}(${relativePath})`;
   const ruleDecision = permissionRulesEngine.checkPermission(toolPattern, { filepath: filePath });
   if (ruleDecision === "deny") {
@@ -25566,7 +25661,7 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (ruleDecision === "allow") {
     return { allowed: true, reason: `File "${filePath}" allowed by permission rules.` };
   }
-  const dirPath = path41.dirname(relativePath);
+  const dirPath = path42.dirname(relativePath);
   const dirPattern = `${toolName}(${dirPath}/**)`;
   const dirRuleDecision = permissionRulesEngine.checkPermission(dirPattern, { filepath: filePath });
   if (dirRuleDecision === "allow") {
@@ -25784,10 +25879,10 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryConsolidate.ts
 import * as fs38 from "fs";
-import * as path42 from "path";
+import * as path43 from "path";
 import os26 from "os";
 function memoryPath2() {
-  return path42.join(process.env.HOME || os26.homedir(), ".bluma", "coding_memory.json");
+  return path43.join(process.env.HOME || os26.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -26349,16 +26444,16 @@ var BluMaToolRunner = class {
 
 // src/app/agent/session_manager/session_archive.ts
 init_bluma_app_dir();
-import path43 from "path";
+import path44 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 = path43.join(appDir, "sessions", "archive", sessionId);
+  const dir = path44.join(appDir, "sessions", "archive", sessionId);
   await fs39.mkdir(dir, { recursive: true });
-  const archiveFile = path43.join(dir, `${Date.now()}.jsonl`);
+  const archiveFile = path44.join(dir, `${Date.now()}.jsonl`);
   const lines = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
   await fs39.appendFile(archiveFile, lines, "utf-8");
   return archiveFile;
@@ -27112,7 +27207,7 @@ init_paths();
 
 // src/app/agent/memory/memdir/memory_scan.ts
 init_memoryTypes();
-import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
+import { readdir as readdir2, readFile as readFile5, stat } from "fs/promises";
 import { join as join12 } from "path";
 var MAX_MEMORY_FILES = 200;
 var FRONTMATTER_MAX_LINES = 30;
@@ -27154,7 +27249,7 @@ async function scanMemoryFiles(memoryDir, _signal) {
     for (const relativePath of mdFiles) {
       const filePath = join12(memoryDir, relativePath);
       try {
-        const raw = await readFile4(filePath, "utf-8");
+        const raw = await readFile5(filePath, "utf-8");
         const head = raw.split("\n").slice(0, FRONTMATTER_MAX_LINES).join("\n");
         const frontmatter = parseSimpleFrontmatter(head);
         const st = await stat(filePath);
@@ -27221,7 +27316,7 @@ Update existing files instead of duplicating.` : "";
 
 // src/app/agent/memory/memory_tool_policy.ts
 init_paths();
-import path44 from "path";
+import path45 from "path";
 var MEMORY_READ_TOOLS = /* @__PURE__ */ new Set([
   "read_file_lines",
   "grep_search",
@@ -27248,7 +27343,7 @@ function isReadOnlyShellCommand(command) {
   return READ_ONLY_SHELL.test(trimmed);
 }
 function createAutoMemToolGate(memoryDir) {
-  const memRoot = memoryDir.endsWith(path44.sep) ? memoryDir : memoryDir + path44.sep;
+  const memRoot = memoryDir.endsWith(path45.sep) ? memoryDir : memoryDir + path45.sep;
   return (toolName, args) => {
     if (MEMORY_READ_TOOLS.has(toolName)) {
       return { allowed: true };
@@ -27261,7 +27356,7 @@ function createAutoMemToolGate(memoryDir) {
     }
     if (MEMORY_WRITE_TOOLS.has(toolName)) {
       const fp = extractFilePath(args);
-      if (fp && isAutoMemPath(path44.resolve(fp))) {
+      if (fp && isAutoMemPath(path45.resolve(fp))) {
         return { allowed: true };
       }
       return { allowed: false, reason: `Writes must stay under ${memRoot}` };
@@ -27270,18 +27365,18 @@ function createAutoMemToolGate(memoryDir) {
   };
 }
 function createSessionMemoryToolGate(sessionMemoryPath) {
-  const resolvedTarget = path44.resolve(sessionMemoryPath);
+  const resolvedTarget = path45.resolve(sessionMemoryPath);
   return (toolName, args) => {
     if (toolName === "read_file_lines") {
       const fp = extractFilePath(args);
-      if (fp && path44.resolve(fp) === resolvedTarget) {
+      if (fp && path45.resolve(fp) === resolvedTarget) {
         return { allowed: true };
       }
       return { allowed: false, reason: "Session memory subagent may only read the session summary file" };
     }
     if (toolName === "edit_tool") {
       const fp = extractFilePath(args);
-      if (fp && path44.resolve(fp) === resolvedTarget) {
+      if (fp && path45.resolve(fp) === resolvedTarget) {
         return { allowed: true };
       }
       return { allowed: false, reason: "Session memory subagent may only edit the session summary file" };
@@ -27308,7 +27403,7 @@ function hasAutoMemWritesSinceHistory(history, sinceIndex) {
         continue;
       }
       const fp = extractFilePath(args);
-      if (fp && isAutoMemPath(path44.resolve(fp))) {
+      if (fp && isAutoMemPath(path45.resolve(fp))) {
         return true;
       }
     }
@@ -27527,7 +27622,7 @@ function scheduleExtractMemories(deps) {
 
 // src/app/agent/memory/session_memory_update.ts
 init_session_memory_paths();
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
 
 // src/app/agent/memory/session_memory_prompts.ts
 init_session_memory_paths();
@@ -27639,9 +27734,9 @@ async function runSessionMemoryUpdate(deps) {
     const memoryPath3 = getSessionMemoryPath(sessionId);
     let currentMemory = "";
     try {
-      currentMemory = await readFile5(memoryPath3, "utf-8");
+      currentMemory = await readFile6(memoryPath3, "utf-8");
     } catch {
-      await writeFile3(memoryPath3, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
+      await writeFile4(memoryPath3, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
 `, "utf-8");
       currentMemory = DEFAULT_SESSION_MEMORY_TEMPLATE;
     }
@@ -27776,7 +27871,7 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     try {
       const sessionData = {
-        session_id: path45.basename(this.sessionFile, ".json"),
+        session_id: path46.basename(this.sessionFile, ".json"),
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: this.history,
         last_updated: (/* @__PURE__ */ new Date()).toISOString(),
@@ -27988,7 +28083,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path45.basename(toolArgs.file_path);
+      const filename = path46.basename(toolArgs.file_path);
       return createDiff(filename, editData.currentContent || "", editData.newContent);
     } catch (e) {
       return `An unexpected error occurred while generating the edit preview: ${e.message}`;
@@ -28725,14 +28820,14 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 // src/app/agent/core/memory/session_memory.ts
 import fs41 from "fs";
 import os29 from "os";
-import path46 from "path";
+import path47 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path46.join(os29.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path47.join(os29.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -29341,14 +29436,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path59, handler) {
-    this.routeHandlers.set(path59, handler);
+  registerRoute(path60, handler) {
+    this.routeHandlers.set(path60, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext, options } = payload;
-    for (const [path59, handler] of this.routeHandlers) {
-      if (inputText === path59 || inputText.startsWith(`${path59} `)) {
+    for (const [path60, handler] of this.routeHandlers) {
+      if (inputText === path60 || inputText.startsWith(`${path60} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -29357,13 +29452,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path47 from "path";
+import path48 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function loadPluginsAtStartup() {
   for (const p of listPlugins()) {
     const entry = p.manifest.entry?.trim();
     if (!entry) continue;
-    const abs = path47.resolve(p.root, entry);
+    const abs = path48.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -29384,7 +29479,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path48.join(os30.homedir(), ".bluma", ".env");
+var globalEnvPath = path49.join(os30.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -31240,10 +31335,10 @@ function resolveToolPayload(result) {
 
 // src/app/ui/components/FilePathLink.tsx
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import path50 from "node:path";
+import path51 from "node:path";
 
 // src/app/ui/utils/pathDisplay.ts
-import path49 from "node:path";
+import path50 from "node:path";
 import os31 from "node:os";
 function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
   let s = String(pathInput ?? "").trim();
@@ -31251,17 +31346,17 @@ function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
     s = s.replace(/[/\\]+$/, "");
   }
   if (!s) return "";
-  const abs = path49.isAbsolute(s) ? path49.normalize(s) : path49.resolve(cwd2, s);
-  const resolvedCwd = path49.resolve(cwd2);
-  const rel = path49.relative(resolvedCwd, abs);
-  if (rel === "" || !rel.startsWith("..") && !path49.isAbsolute(rel)) {
+  const abs = path50.isAbsolute(s) ? path50.normalize(s) : path50.resolve(cwd2, s);
+  const resolvedCwd = path50.resolve(cwd2);
+  const rel = path50.relative(resolvedCwd, abs);
+  if (rel === "" || !rel.startsWith("..") && !path50.isAbsolute(rel)) {
     return rel === "" ? "." : rel;
   }
-  const home = path49.normalize(os31.homedir());
-  if (abs === home || abs.startsWith(home + path49.sep)) {
+  const home = path50.normalize(os31.homedir());
+  if (abs === home || abs.startsWith(home + path50.sep)) {
     return "~" + abs.slice(home.length);
   }
-  return path49.basename(abs);
+  return path50.basename(abs);
 }
 
 // src/app/ui/components/FilePathLink.tsx
@@ -31271,7 +31366,7 @@ function FilePathLink({ filePath, children, cwd: cwd2 = process.cwd(), color })
   if (!raw) {
     return null;
   }
-  const abs = path50.isAbsolute(raw) ? path50.normalize(raw) : path50.resolve(cwd2, raw);
+  const abs = path51.isAbsolute(raw) ? path51.normalize(raw) : path51.resolve(cwd2, raw);
   const href = pathToFileURL3(abs).href;
   const label = formatPathForDisplay(abs, cwd2);
   const text = typeof children === "string" ? children : label;
@@ -33906,13 +34001,13 @@ function EditToolDiffPanel({
   newString,
   replaceAll = false
 }) {
-  const path59 = filePath.trim() || "unknown file";
+  const path60 = filePath.trim() || "unknown file";
   const hasPreviewArgs = oldString !== void 0 && newString !== void 0;
   const hasDiffText = diffText && diffText.trim().length > 0;
   return /* @__PURE__ */ jsx43(Box_default, { flexDirection: "column", children: hasPreviewArgs ? /* @__PURE__ */ jsx43(Box_default, { marginTop: 0, children: /* @__PURE__ */ jsx43(
     FileEditToolDiff,
     {
-      filePath: path59,
+      filePath: path60,
       oldString,
       newString,
       replaceAll,
@@ -33950,7 +34045,7 @@ function renderToolUseMessage12({ args }) {
   return /* @__PURE__ */ jsx44(Text, { color: BLUMA_TERMINAL.blue, children: p });
 }
 function renderToolHeader12({ args }) {
-  const path59 = args?.file_path ?? ".";
+  const path60 = args?.file_path ?? ".";
   const oldText = typeof args?.old_string === "string" ? args.old_string : "";
   const newText = typeof args?.new_string === "string" ? args.new_string : "";
   const counts = countLineDiff(oldText, newText);
@@ -33960,7 +34055,7 @@ function renderToolHeader12({ args }) {
       action,
       /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
         " ",
-        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path59, color: BLUMA_TERMINAL.dim })
+        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path60, color: BLUMA_TERMINAL.dim })
       ] })
     ] }),
     /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
@@ -34352,11 +34447,11 @@ function userFacingName13() {
 }
 function renderToolUseMessage14({ args }) {
   const q = args?.query ? `"${args.query}"` : "...";
-  const path59 = args?.path || ".";
+  const path60 = args?.path || ".";
   return /* @__PURE__ */ jsxs30(Box_default, { flexDirection: "row", flexWrap: "wrap", alignItems: "flex-end", children: [
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.blue, children: q }),
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.dim, children: " " }),
-    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path59, color: BLUMA_TERMINAL.dim })
+    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path60, color: BLUMA_TERMINAL.dim })
   ] });
 }
 function renderToolHeader14({ args }) {
@@ -37836,7 +37931,7 @@ import {
 // src/app/ui/hooks/useAtCompletion.ts
 import { useEffect as useEffect11, useRef as useRef4, useState as useState13 } from "react";
 import fs44 from "fs";
-import path51 from "path";
+import path52 from "path";
 var MAX_RESULTS3 = 50;
 var DEFAULT_RECURSIVE_DEPTH = 2;
 function listPathSuggestions(baseDir, pattern) {
@@ -37844,7 +37939,7 @@ function listPathSuggestions(baseDir, pattern) {
   const patternEndsWithSlash = raw.endsWith("/");
   const relDir = raw.replace(/^\/+|\/+$/g, "");
   const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
-  const listDir = path51.resolve(baseDir, relDir || ".");
+  const listDir = path52.resolve(baseDir, relDir || ".");
   const results = [];
   const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
   const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
@@ -37861,7 +37956,7 @@ function listPathSuggestions(baseDir, pattern) {
   }
   function pushEntry(entryPath, label, isDir) {
     if (results.length >= MAX_RESULTS3) return;
-    const clean = label.split(path51.sep).join("/").replace(/[]+/g, "");
+    const clean = label.split(path52.sep).join("/").replace(/[]+/g, "");
     results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
   }
   try {
@@ -37873,8 +37968,8 @@ function listPathSuggestions(baseDir, pattern) {
           const entries = fs44.readdirSync(node.dir, { withFileTypes: true });
           for (const entry of entries) {
             if (isIgnoredName(entry.name)) continue;
-            const entryAbs = path51.join(node.dir, entry.name);
-            const entryRel = node.rel ? path51.posix.join(node.rel, entry.name) : entry.name;
+            const entryAbs = path52.join(node.dir, entry.name);
+            const entryRel = node.rel ? path52.posix.join(node.rel, entry.name) : entry.name;
             if (entryRel.split("/").includes("node_modules")) continue;
             if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
             pushEntry(entryAbs, entryRel, entry.isDirectory());
@@ -37892,8 +37987,8 @@ function listPathSuggestions(baseDir, pattern) {
         if (filterPrefix && !entry.name.startsWith(filterPrefix)) continue;
         if (isIgnoredName(entry.name)) continue;
         if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
-        const entryAbs = path51.join(listDir, entry.name);
-        const label = relDir ? path51.posix.join(relDir, entry.name) : entry.name;
+        const entryAbs = path52.join(listDir, entry.name);
+        const label = relDir ? path52.posix.join(relDir, entry.name) : entry.name;
         pushEntry(entryAbs, label, entry.isDirectory());
         if (results.length >= MAX_RESULTS3) break;
       }
@@ -38096,7 +38191,7 @@ var SlashSubmenuInline = memo15(SlashSubmenuInlineComponent);
 // src/app/ui/utils/clipboardImage.ts
 import fs45 from "fs";
 import os32 from "os";
-import path52 from "path";
+import path53 from "path";
 import { spawn as spawn5, execFile as execFileCb, execSync as execSync4 } from "child_process";
 import { promisify as promisify2 } from "util";
 
@@ -38225,8 +38320,8 @@ function commandOnPath(cmd) {
 function unixClipboardHelperDirs() {
   const h = os32.homedir();
   return [
-    path52.join(h, ".local", "bin"),
-    path52.join(h, "bin"),
+    path53.join(h, ".local", "bin"),
+    path53.join(h, "bin"),
     "/usr/bin",
     "/usr/local/bin",
     "/bin",
@@ -38244,7 +38339,7 @@ function resolveHelperBinary(cmd) {
     return cmd;
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path52.join(dir, cmd);
+    const full = path53.join(dir, cmd);
     try {
       fs45.accessSync(full, fs45.constants.X_OK);
       return full;
@@ -38252,7 +38347,7 @@ function resolveHelperBinary(cmd) {
     }
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path52.join(dir, cmd);
+    const full = path53.join(dir, cmd);
     if (fs45.existsSync(full)) {
       return full;
     }
@@ -38294,7 +38389,7 @@ function writeBufferIfImage(baseDir, buf) {
   if (!ext) {
     return null;
   }
-  const out = path52.join(
+  const out = path53.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
@@ -38333,9 +38428,9 @@ async function tryDarwinClipboardy(baseDir) {
       if (st.size < 80 || st.size > CLIPBOARD_MAX_BYTES) {
         continue;
       }
-      const ext = path52.extname(src).toLowerCase();
+      const ext = path53.extname(src).toLowerCase();
       const safeExt = ext && /^\.(png|jpe?g|gif|webp)$/i.test(ext) ? ext : ".png";
-      const out = path52.join(
+      const out = path53.join(
         baseDir,
         `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${safeExt}`
       );
@@ -38353,7 +38448,7 @@ async function tryDarwinClipboardy(baseDir) {
   return null;
 }
 async function tryWindowsPowerShell(outFile) {
-  const ps = process.env.SystemRoot != null ? path52.join(
+  const ps = process.env.SystemRoot != null ? path53.join(
     process.env.SystemRoot,
     "System32",
     "WindowsPowerShell",
@@ -38454,8 +38549,8 @@ function parseClipboardTextAsImagePath(raw) {
     s = s.slice(1, -1);
   }
   s = s.trim();
-  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path52.extname(s))) return null;
-  const abs = path52.isAbsolute(s) ? path52.normalize(s) : path52.resolve(process.cwd(), s);
+  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path53.extname(s))) return null;
+  const abs = path53.isAbsolute(s) ? path53.normalize(s) : path53.resolve(process.cwd(), s);
   return abs;
 }
 async function tryClipboardTextAsImageFile(baseDir) {
@@ -38475,8 +38570,8 @@ async function tryClipboardTextAsImageFile(baseDir) {
   } catch {
     return null;
   }
-  const ext = path52.extname(abs).toLowerCase();
-  const out = path52.join(
+  const ext = path53.extname(abs).toLowerCase();
+  const out = path53.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
@@ -38491,7 +38586,7 @@ async function tryLinuxShellPipelineSave(baseDir) {
   if (process.platform !== "linux" && process.platform !== "freebsd") {
     return null;
   }
-  const outPath = path52.join(
+  const outPath = path53.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`
   );
@@ -38549,7 +38644,7 @@ async function tryNativeClipboardImage() {
   return null;
 }
 async function readClipboardImageToTempFile() {
-  const baseDir = path52.join(os32.homedir(), ".cache", "bluma", "clipboard");
+  const baseDir = path53.join(os32.homedir(), ".cache", "bluma", "clipboard");
   fs45.mkdirSync(baseDir, { recursive: true });
   const nativeResult = await tryNativeClipboardImage();
   if (nativeResult) {
@@ -38568,7 +38663,7 @@ async function readClipboardImageToTempFile() {
     }
   }
   if (process.platform === "win32") {
-    const outFile = path52.join(
+    const outFile = path53.join(
       baseDir,
       `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`
     );
@@ -40944,7 +41039,7 @@ var renderSettingsEditUsage = () => {
 
 // src/app/agent/core/thread/thread_store.ts
 init_bluma_app_dir();
-import path53 from "path";
+import path54 from "path";
 import { promises as fs47 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 var INDEX_VERSION = 1;
@@ -40970,9 +41065,9 @@ var ThreadStore = class {
   packageVersion;
   constructor() {
     const appDir = getPreferredAppDir();
-    this.threadsDir = path53.join(appDir, "threads");
-    this.archiveDir = path53.join(this.threadsDir, "archive");
-    this.indexPath = path53.join(this.threadsDir, "index.json");
+    this.threadsDir = path54.join(appDir, "threads");
+    this.archiveDir = path54.join(this.threadsDir, "archive");
+    this.indexPath = path54.join(this.threadsDir, "index.json");
     this.packageVersion = process.env.npm_package_version || "0.0.0";
   }
   // ==================== Inicialização ====================
@@ -41094,7 +41189,7 @@ var ThreadStore = class {
       messages: params.initialMessages || []
     };
     const historyPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path53.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path54.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -41149,7 +41244,7 @@ var ThreadStore = class {
       compressedSliceCount: source.history.compressedSliceCount
     };
     const historyPath = this.buildDatedThreadHistoryPath(newThreadId);
-    await fs47.mkdir(path53.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path54.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -41222,7 +41317,7 @@ var ThreadStore = class {
     const entry = index.threads[entryIndex];
     if (entry.status === "archived") return true;
     const oldPath = entry.historyPath || this.getLegacyHistoryPath(threadId);
-    const newPath = path53.join(this.archiveDir, `${threadId}.jsonl`);
+    const newPath = path54.join(this.archiveDir, `${threadId}.jsonl`);
     try {
       await fs47.rename(oldPath, newPath);
     } catch (e) {
@@ -41245,9 +41340,9 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     if (entry.status === "active") return true;
-    const oldPath = path53.join(this.archiveDir, `${threadId}.jsonl`);
+    const oldPath = path54.join(this.archiveDir, `${threadId}.jsonl`);
     const newPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path53.dirname(newPath), { recursive: true });
+    await fs47.mkdir(path54.dirname(newPath), { recursive: true });
     try {
       await fs47.rename(oldPath, newPath);
     } catch (e) {
@@ -41280,14 +41375,14 @@ var ThreadStore = class {
   }
   // ==================== Histórico ====================
   getLegacyHistoryPath(threadId) {
-    return path53.join(this.threadsDir, `${threadId}.jsonl`);
+    return path54.join(this.threadsDir, `${threadId}.jsonl`);
   }
   /** ~/.bluma/threads/YYYY/MM/DD/<threadId>.jsonl (data local de criação). */
   buildDatedThreadHistoryPath(threadId, at = /* @__PURE__ */ new Date()) {
     const y = String(at.getFullYear());
     const mo = String(at.getMonth() + 1).padStart(2, "0");
     const d = String(at.getDate()).padStart(2, "0");
-    return path53.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
+    return path54.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
   }
   async resolveHistoryPath(threadId) {
     const index = await this.loadIndex();
@@ -41318,7 +41413,7 @@ var ThreadStore = class {
     for (const msg of history.messages) {
       lines.push(JSON.stringify({ type: "message", ...msg }));
     }
-    await fs47.mkdir(path53.dirname(historyPath), { recursive: true }).catch(() => {
+    await fs47.mkdir(path54.dirname(historyPath), { recursive: true }).catch(() => {
     });
     await fs47.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
   }
@@ -43814,13 +43909,13 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath7 } from "url";
-import path55 from "path";
+import path56 from "path";
 import fs49 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
 function findBlumaPackageJson(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
-    const candidate = path55.join(dir, "package.json");
+    const candidate = path56.join(dir, "package.json");
     if (fs49.existsSync(candidate)) {
       try {
         const raw = fs49.readFileSync(candidate, "utf8");
@@ -43831,7 +43926,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path55.dirname(dir);
+    const parent = path56.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -43840,13 +43935,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path55.resolve(dir);
+    const abs = path56.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path55.dirname(fileURLToPath7(import.meta.url)));
+    const fromBundle = tryFrom(path56.dirname(fileURLToPath7(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -43854,12 +43949,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path55.isAbsolute(argv1) && fs49.existsSync(argv1)) {
+      if (path56.isAbsolute(argv1) && fs49.existsSync(argv1)) {
         resolved = fs49.realpathSync(argv1);
       } else {
-        resolved = path55.resolve(process.cwd(), argv1);
+        resolved = path56.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path55.dirname(resolved));
+      const fromArgv = tryFrom(path56.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -44679,9 +44774,9 @@ function usePlanMode() {
 // src/app/hooks/useAgentMode.ts
 import { useState as useState22, useEffect as useEffect21, useCallback as useCallback9 } from "react";
 import * as fs50 from "fs";
-import * as path56 from "path";
+import * as path57 from "path";
 import { homedir as homedir4 } from "os";
-var SETTINGS_PATH = path56.join(homedir4(), ".bluma", "settings.json");
+var SETTINGS_PATH = path57.join(homedir4(), ".bluma", "settings.json");
 function readAgentModeFromFile() {
   try {
     if (!fs50.existsSync(SETTINGS_PATH)) {
@@ -44707,7 +44802,7 @@ function useAgentMode() {
   const updateAgentMode = useCallback9((mode) => {
     try {
       if (!fs50.existsSync(SETTINGS_PATH)) {
-        fs50.mkdirSync(path56.dirname(SETTINGS_PATH), { recursive: true });
+        fs50.mkdirSync(path57.dirname(SETTINGS_PATH), { recursive: true });
       }
       let settings = {};
       if (fs50.existsSync(SETTINGS_PATH)) {
@@ -44839,7 +44934,6 @@ function ScrollBox({
     // notify/scrollMutated are inline (no useCallback) but only close over
     // refs + imports — stable. Empty deps avoids rebuilding the handle on
     // every render (which re-registers the ref = churn).
-    // eslint-disable-next-line react-hooks/exhaustive-deps
     []
   );
   return /* @__PURE__ */ jsx103("ink-box", { ref: (el) => {
@@ -45980,10 +46074,10 @@ import { memo as memo26, useCallback as useCallback11, useEffect as useEffect23,
 
 // src/app/agent/session_manager/session_resume_browser.ts
 init_bluma_app_dir();
-import path57 from "path";
+import path58 from "path";
 import { promises as fs51 } from "fs";
 function getSessionsRoot() {
-  return path57.join(getPreferredAppDir(), "sessions");
+  return path58.join(getPreferredAppDir(), "sessions");
 }
 function normalizeSessionsCwd(cwd2) {
   return cwd2.replace(/\\/g, "/").split("/").filter((p) => p && p !== "." && p !== "..").join("/");
@@ -46034,7 +46128,7 @@ function compareDirNames(a, b) {
 async function listSessionBrowserEntries(cwdRel) {
   const cwd2 = normalizeSessionsCwd(cwdRel);
   const root = getSessionsRoot();
-  const absDir = cwd2 ? path57.join(root, ...cwd2.split("/")) : root;
+  const absDir = cwd2 ? path58.join(root, ...cwd2.split("/")) : root;
   const out = [];
   if (cwd2) {
     out.push({ kind: "up", label: ".." });
@@ -46051,7 +46145,7 @@ async function listSessionBrowserEntries(cwdRel) {
   for (const e of dirents) {
     const name = String(e.name);
     if (name.startsWith(".")) continue;
-    const full = path57.join(absDir, name);
+    const full = path58.join(absDir, name);
     if (e.isDirectory()) {
       dirNames.push(name);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -46061,7 +46155,7 @@ async function listSessionBrowserEntries(cwdRel) {
   dirNames.sort(compareDirNames);
   const sessions = [];
   for (const { name, full } of sessionFiles) {
-    const sessionId = path57.basename(name, ".json");
+    const sessionId = path58.basename(name, ".json");
     sessions.push(await sessionEntryFromFile(full, sessionId));
   }
   sessions.sort((a, b) => {
@@ -46669,8 +46763,8 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path58.dirname(fileURLToPath8(import.meta.url));
-    const pkgPath = path58.join(base, "..", "package.json");
+    const base = path59.dirname(fileURLToPath8(import.meta.url));
+    const pkgPath = path59.join(base, "..", "package.json");
     const j = JSON.parse(fs52.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {