@nomad-e/bluma-cli 0.11.0 → 0.11.1

package/dist/main.js

@@ -2201,11 +2201,11 @@ var NodeFsOperations = {
       if (fd) fs.closeSync(fd);
     }
   },
-  appendFileSync(path56, data, options) {
-    const _ = slowLogging`fs.appendFileSync(${path56}, ${data.length} chars)`;
+  appendFileSync(path57, data, options) {
+    const _ = slowLogging`fs.appendFileSync(${path57}, ${data.length} chars)`;
     if (options?.mode !== void 0) {
       try {
-        const fd = fs.openSync(path56, "ax", options.mode);
+        const fd = fs.openSync(path57, "ax", options.mode);
         try {
           fs.appendFileSync(fd, data);
         } finally {
@@ -2216,35 +2216,35 @@ var NodeFsOperations = {
         if (getErrnoCode(e) !== "EEXIST") throw e;
       }
     }
-    fs.appendFileSync(path56, data);
+    fs.appendFileSync(path57, data);
   },
   copyFileSync(src, dest) {
     const _ = slowLogging`fs.copyFileSync(${src} → ${dest})`;
     fs.copyFileSync(src, dest);
   },
-  unlinkSync(path56) {
-    const _ = slowLogging`fs.unlinkSync(${path56})`;
-    fs.unlinkSync(path56);
+  unlinkSync(path57) {
+    const _ = slowLogging`fs.unlinkSync(${path57})`;
+    fs.unlinkSync(path57);
   },
   renameSync(oldPath, newPath) {
     const _ = slowLogging`fs.renameSync(${oldPath} → ${newPath})`;
     fs.renameSync(oldPath, newPath);
   },
-  linkSync(target, path56) {
-    const _ = slowLogging`fs.linkSync(${target} → ${path56})`;
-    fs.linkSync(target, path56);
+  linkSync(target, path57) {
+    const _ = slowLogging`fs.linkSync(${target} → ${path57})`;
+    fs.linkSync(target, path57);
   },
-  symlinkSync(target, path56, type) {
-    const _ = slowLogging`fs.symlinkSync(${target} → ${path56})`;
-    fs.symlinkSync(target, path56, type);
+  symlinkSync(target, path57, type) {
+    const _ = slowLogging`fs.symlinkSync(${target} → ${path57})`;
+    fs.symlinkSync(target, path57, type);
   },
-  readlinkSync(path56) {
-    const _ = slowLogging`fs.readlinkSync(${path56})`;
-    return fs.readlinkSync(path56);
+  readlinkSync(path57) {
+    const _ = slowLogging`fs.readlinkSync(${path57})`;
+    return fs.readlinkSync(path57);
   },
-  realpathSync(path56) {
-    const _ = slowLogging`fs.realpathSync(${path56})`;
-    return fs.realpathSync(path56).normalize("NFC");
+  realpathSync(path57) {
+    const _ = slowLogging`fs.realpathSync(${path57})`;
+    return fs.realpathSync(path57).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(path56, options) {
-    const _ = slowLogging`fs.rmSync(${path56})`;
-    fs.rmSync(path56, options);
+  rmSync(path57, options) {
+    const _ = slowLogging`fs.rmSync(${path57})`;
+    fs.rmSync(path57, options);
   },
-  createWriteStream(path56) {
-    return fs.createWriteStream(path56);
+  createWriteStream(path57) {
+    return fs.createWriteStream(path57);
   },
   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, path56, content) {
+async function appendAsync(needMkdir, dir, path57, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {
     });
   }
-  await appendFile(path56, content);
+  await appendFile(path57, content);
   void updateLatestDebugLogSymlink();
 }
 function noop() {
@@ -2404,8 +2404,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path56 = getDebugLogPath();
-        const dir = dirname(path56);
+        const path57 = getDebugLogPath();
+        const dir = dirname(path57);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -2415,11 +2415,11 @@ function getDebugWriter() {
             } catch {
             }
           }
-          getFsImplementation().appendFileSync(path56, content);
+          getFsImplementation().appendFileSync(path57, content);
           void updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path56, content)).catch(noop);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path57, 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 = (path56) => {
-  return path56?.replace(`file://${process.cwd()}/`, "");
+var cleanupPath = (path57) => {
+  return path57?.replace(`file://${process.cwd()}/`, "");
 };
 var stackUtils;
 function getStackUtils() {
@@ -12585,7 +12585,7 @@ var getInstance = (stdout, createInstance) => {
 // src/main.ts
 import { EventEmitter as EventEmitter7 } from "events";
 import fs51 from "fs";
-import path55 from "path";
+import path56 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
@@ -13479,12 +13479,12 @@ function cancelSlashSubmenu() {
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path46 from "path";
+import path47 from "path";
 import os31 from "os";
 
 // src/app/agent/tool_invoker.ts
 import { promises as fs25 } from "fs";
-import path26 from "path";
+import path27 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/agent/tools/EditTool/EditTool.ts
@@ -19066,11 +19066,13 @@ async function createNextApp(args) {
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 init_sandbox_policy();
 import { promises as fs24 } from "fs";
+import path26 from "path";
+
+// src/app/agent/tools/DeployAppTool/createDeployProjectZip.ts
+import { lstat, readdir, readFile, writeFile } from "fs/promises";
 import path25 from "path";
-function shQuote(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-var EXCLUDE_PATTERNS = [
+import { minimatch as minimatch2 } from "minimatch";
+var DEPLOY_ZIP_EXCLUDE_PATTERNS = [
   "node_modules",
   ".next",
   ".git",
@@ -19083,62 +19085,116 @@ var EXCLUDE_PATTERNS = [
   ".env*.local",
   "coverage",
   ".vercel",
-  ".turbo"
+  ".turbo",
+  ".tmp"
 ];
-function zipExcludeArg(pattern) {
-  if (pattern.includes("*") || pattern.startsWith(".")) {
-    return pattern;
-  }
-  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,
-    timeout: 120
-    // 2 minutos para zippar
-  });
-  const resultJson = JSON.parse(result);
-  if (resultJson.status !== "success") {
-    throw new Error(`Failed to create ZIP: ${resultJson.stderr}`);
+function pathSegments(relativePosix) {
+  return relativePosix.split("/").filter(Boolean);
+}
+function shouldExcludeFromDeployZip(relativePosix, isDirectory) {
+  const rel = relativePosix.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!rel) return false;
+  const segments = pathSegments(rel);
+  const baseName = path25.posix.basename(rel);
+  for (const pattern of DEPLOY_ZIP_EXCLUDE_PATTERNS) {
+    if (pattern.includes("*")) {
+      if (minimatch2(rel, pattern) || minimatch2(baseName, pattern)) {
+        return true;
+      }
+      continue;
+    }
+    if (segments.includes(pattern)) {
+      return true;
+    }
+    if (!isDirectory && baseName === pattern) {
+      return true;
+    }
   }
+  return false;
+}
+async function collectDeployZipEntries(projectDir, files) {
+  const base = path25.resolve(projectDir);
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path25.join(currentDir, entry.name);
+      const rel = path25.relative(base, fullPath).replace(/\\/g, "/");
+      if (shouldExcludeFromDeployZip(rel, entry.isDirectory())) {
+        continue;
+      }
+      if (entry.isSymbolicLink()) {
+        try {
+          const st = await lstat(fullPath);
+          if (st.isDirectory()) continue;
+        } catch {
+          continue;
+        }
+      }
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      try {
+        const content = await readFile(fullPath);
+        files[rel] = new Uint8Array(content);
+      } catch {
+      }
+    }
+  }
+  await walk(base);
+}
+async function createDeployProjectZip(projectDir, zipPath) {
+  const files = {};
+  await collectDeployZipEntries(projectDir, files);
+  const fileCount = Object.keys(files).length;
+  if (fileCount === 0) {
+    throw new Error("No files to include in deploy ZIP (check project directory and exclusions)");
+  }
+  const { zipSync } = await import("fflate");
+  const zipData = zipSync(files, { level: 6 });
+  await writeFile(zipPath, zipData);
   return zipPath;
 }
+
+// src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
   const deployUrl = `${severinoUrl.replace(/\/$/, "")}/api/v1/deploy`;
-  const curlArgs = [
-    "-sS",
-    "-X",
-    "POST",
-    deployUrl,
-    "-F",
-    `file=@${zipPath}`
-  ];
-  if (name) {
-    curlArgs.push("-F", `name=${name}`);
-  }
-  if (appId) {
-    curlArgs.push("-F", `appId=${appId}`);
-  }
+  const zipBytes = await fs24.readFile(zipPath);
+  const form = new FormData();
+  form.append(
+    "file",
+    new Blob([zipBytes], { type: "application/zip" }),
+    path26.basename(zipPath)
+  );
+  if (name) form.append("name", name);
+  if (appId) form.append("appId", appId);
+  const headers = { Accept: "application/json" };
   if (apiKey) {
-    curlArgs.push("-H", `Authorization: Bearer ${apiKey}`);
-    curlArgs.push("-H", `X-API-Key: ${apiKey}`);
-  }
-  curlArgs.push("-H", "Accept: application/json");
-  const curlCommand = `curl ${curlArgs.map(shQuote).join(" ")}`;
-  const result = await shellCommand({
-    command: curlCommand,
-    timeout: 60
-    // 1 minuto para upload
+    headers.Authorization = `Bearer ${apiKey}`;
+    headers["X-API-Key"] = apiKey;
+  }
+  const httpResponse = await fetch(deployUrl, {
+    method: "POST",
+    body: form,
+    headers,
+    signal: AbortSignal.timeout(12e4)
   });
-  const resultJson = JSON.parse(result);
-  if (resultJson.status !== "success") {
-    throw new Error(`Upload failed: ${resultJson.stderr}`);
+  const responseText = await httpResponse.text();
+  if (!httpResponse.ok) {
+    throw new Error(
+      `Upload failed (${httpResponse.status}): ${responseText.slice(0, 500)}`
+    );
   }
   try {
-    const response = JSON.parse(resultJson.stdout);
+    const response = JSON.parse(responseText);
     if (response.success === false || response.error) {
       const errorMsg = typeof response.error === "string" ? response.error : response.error?.message || "Deploy failed";
       return {
@@ -19225,7 +19281,7 @@ function buildFactorAiManifest(appContext, deployResult, appName) {
 }
 async function writeFactorAiManifest(projectDir, appContext, deployResult, appName) {
   const manifest = buildFactorAiManifest(appContext, deployResult, appName);
-  const manifestPath = path25.join(projectDir, "factorai.sh.json");
+  const manifestPath = path26.join(projectDir, "factorai.sh.json");
   await fs24.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   return manifest;
@@ -19253,7 +19309,7 @@ async function deployApp(args) {
         error: `Project directory not found: ${resolvedProjectDir}`
       };
     }
-    const packageJsonPath = path25.join(resolvedProjectDir, "package.json");
+    const packageJsonPath = path26.join(resolvedProjectDir, "package.json");
     try {
       await fs24.access(packageJsonPath);
     } catch {
@@ -19271,12 +19327,12 @@ async function deployApp(args) {
         error: "Not a Next.js project: next not found in dependencies"
       };
     }
-    const appName = name || packageJson.name || path25.basename(resolvedProjectDir);
-    const tempDir = path25.join(resolvedProjectDir, ".tmp");
+    const appName = name || packageJson.name || path26.basename(resolvedProjectDir);
+    const tempDir = path26.join(resolvedProjectDir, ".tmp");
     await fs24.mkdir(tempDir, { recursive: true });
-    const zipPath = path25.join(tempDir, `${appName}-${Date.now()}.zip`);
+    const zipPath = path26.join(tempDir, `${appName}-${Date.now()}.zip`);
     console.log(`[deploy-app] Creating ZIP: ${zipPath}`);
-    await createProjectZip(resolvedProjectDir, zipPath);
+    await createDeployProjectZip(resolvedProjectDir, zipPath);
     const zipStats = await fs24.stat(zipPath);
     const zipSizeMB = zipStats.size / 1024 / 1024;
     if (zipSizeMB > 50) {
@@ -19307,7 +19363,7 @@ async function deployApp(args) {
           appName
         );
         deployResult.factoraiManifest = manifest;
-        deployResult.factoraiManifestPath = path25.join(resolvedProjectDir, "factorai.sh.json");
+        deployResult.factoraiManifestPath = path26.join(resolvedProjectDir, "factorai.sh.json");
       }
       console.log(`[deploy-app] Deploy iniciado: ${deployResult.appId}`);
     }
@@ -20389,8 +20445,8 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const currentFilePath = fileURLToPath(import.meta.url);
-      const currentDirPath = path26.dirname(currentFilePath);
-      const configPath = path26.resolve(currentDirPath, "config", "native_tools.json");
+      const currentDirPath = path27.dirname(currentFilePath);
+      const configPath = path27.resolve(currentDirPath, "config", "native_tools.json");
       const fileContent = await fs25.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = applyMetadataToToolDefinitions(config2.nativeTools);
@@ -20439,7 +20495,7 @@ var ToolInvoker = class {
 
 // src/app/agent/tools/mcp/mcp_client.ts
 import { promises as fs26 } from "fs";
-import path27 from "path";
+import path28 from "path";
 import os18 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -20467,9 +20523,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    const __dirname2 = path27.dirname(__filename);
-    const defaultConfigPath = path27.resolve(__dirname2, "config", "bluma-mcp.json");
-    const userConfigPath = path27.join(os18.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname2 = path28.dirname(__filename);
+    const defaultConfigPath = path28.resolve(__dirname2, "config", "bluma-mcp.json");
+    const userConfigPath = path28.join(os18.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -20715,39 +20771,39 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path43 from "path";
+import path44 from "path";
 import fs40 from "fs";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path31 from "path";
+import path32 from "path";
 import { promises as fs29 } from "fs";
 
 // src/app/agent/session_manager/agent_session_paths.ts
-import path30 from "path";
+import path31 from "path";
 import { promises as fs28 } from "fs";
 
 // src/app/agent/session_manager/bluma_app_dir.ts
-import path28 from "path";
+import path29 from "path";
 import os19 from "os";
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path28.join(os19.homedir(), p.slice(1));
+    return path29.join(os19.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
   const fromEnv = process.env.BLUMA_HOME?.trim();
   if (fromEnv) {
-    return path28.resolve(expandHome(fromEnv));
+    return path29.resolve(expandHome(fromEnv));
   }
-  const fixed = path28.join(os19.homedir(), ".bluma");
-  return path28.resolve(expandHome(fixed));
+  const fixed = path29.join(os19.homedir(), ".bluma");
+  return path29.resolve(expandHome(fixed));
 }
 
 // src/app/agent/session_manager/session_index_db.ts
-import path29 from "path";
+import path30 from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 import { promises as fs27 } from "fs";
 import { createRequire } from "module";
@@ -20762,10 +20818,10 @@ function loadSqlite() {
   return nodeRequire("better-sqlite3");
 }
 function getSessionDbPath(appDir = getPreferredAppDir()) {
-  return path29.join(appDir, BLUMA_SESSION_DB_FILE);
+  return path30.join(appDir, BLUMA_SESSION_DB_FILE);
 }
 function normalizeRelativePath(relativePath) {
-  return relativePath.split(path29.sep).join("/");
+  return relativePath.split(path30.sep).join("/");
 }
 async function walkSessionJsonFiles(dir, onFile) {
   let entries;
@@ -20776,7 +20832,7 @@ async function walkSessionJsonFiles(dir, onFile) {
   }
   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);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -20786,7 +20842,7 @@ async function walkSessionJsonFiles(dir, onFile) {
 }
 async function loadJsonlEntries(appDir) {
   const map = /* @__PURE__ */ new Map();
-  const indexFile = path29.join(appDir, AGENT_SESSION_PATHS_JSONL);
+  const indexFile = path30.join(appDir, AGENT_SESSION_PATHS_JSONL);
   let raw;
   try {
     raw = await fs27.readFile(indexFile, "utf-8");
@@ -20866,7 +20922,7 @@ async function runMigrationV1(db, appDir) {
   const insertFromPath = async (sessionId, absPath, jsonlUpdatedAt) => {
     let rel;
     try {
-      rel = normalizeRelativePath(path29.relative(appDir, absPath));
+      rel = normalizeRelativePath(path30.relative(appDir, absPath));
     } catch {
       return;
     }
@@ -20881,7 +20937,7 @@ async function runMigrationV1(db, appDir) {
     });
   };
   for (const [sessionId, entry] of jsonl) {
-    const full = path29.join(appDir, entry.relativePath.replace(/\//g, path29.sep));
+    const full = path30.join(appDir, entry.relativePath.replace(/\//g, path30.sep));
     try {
       await fs27.access(full);
       await insertFromPath(sessionId, full, entry.updatedAt);
@@ -20895,11 +20951,11 @@ async function runMigrationV1(db, appDir) {
       });
     }
   }
-  const sessionsRoot = path29.join(appDir, "sessions");
+  const sessionsRoot = path30.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");
+    const sessionId = path30.basename(absPath, ".json");
     if (!sessionId || seen.has(sessionId)) return;
     seen.add(sessionId);
     await insertFromPath(sessionId, absPath);
@@ -20934,7 +20990,7 @@ async function ensureSessionIndexDb(appDir = getPreferredAppDir()) {
       }
       const BetterSqlite3 = loadSqlite();
       const dbPath = getSessionDbPath(appDir);
-      mkdirSync3(path29.dirname(dbPath), { recursive: true });
+      mkdirSync3(path30.dirname(dbPath), { recursive: true });
       const db = new BetterSqlite3(dbPath);
       db.pragma("journal_mode = WAL");
       applySchema(db);
@@ -20970,7 +21026,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, path29.sep) ?? null;
+  return row?.relative_path?.replace(/\//g, path30.sep) ?? null;
 }
 async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir()) {
   const db = await ensureSessionIndexDb(appDir);
@@ -20982,7 +21038,7 @@ async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir())
   ).all(limit);
   return rows.map((r) => ({
     sessionId: r.session_id,
-    relativePath: r.relative_path.replace(/\//g, path29.sep),
+    relativePath: r.relative_path.replace(/\//g, path30.sep),
     createdAt: r.created_at,
     updatedAt: r.updated_at,
     preview: r.preview
@@ -20994,7 +21050,7 @@ var AGENT_SESSION_PATHS_JSONL2 = "agent_session_paths.jsonl";
 async function appendAgentSessionPath(sessionId, relativePath) {
   const app = getPreferredAppDir();
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const rel = relativePath.split(path30.sep).join("/");
+  const rel = relativePath.split(path31.sep).join("/");
   await upsertSessionIndexRow({
     sessionId,
     relativePath: rel,
@@ -21004,7 +21060,7 @@ async function appendAgentSessionPath(sessionId, relativePath) {
   });
 }
 async function resolveSessionRelativePathFromJsonl(sessionId) {
-  const indexFile = path30.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path31.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   let raw;
   try {
     raw = await fs28.readFile(indexFile, "utf-8");
@@ -21016,7 +21072,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, path30.sep);
+        return row.relativePath.replace(/\//g, path31.sep);
       }
     } catch {
     }
@@ -21037,7 +21093,7 @@ async function walkSessionJsonFiles2(dir, onFile) {
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path30.join(dir, name);
+    const full = path31.join(dir, name);
     if (e.isDirectory()) {
       await walkSessionJsonFiles2(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -21046,10 +21102,10 @@ async function walkSessionJsonFiles2(dir, onFile) {
   }
 }
 async function findSessionFileGlobFallback(sessionId) {
-  const sessionsRoot = path30.join(getPreferredAppDir(), "sessions");
+  const sessionsRoot = path31.join(getPreferredAppDir(), "sessions");
   const state2 = { best: null };
   await walkSessionJsonFiles2(sessionsRoot, async (abs) => {
-    if (path30.basename(abs, ".json") !== sessionId) return;
+    if (path31.basename(abs, ".json") !== sessionId) return;
     try {
       const st = await fs28.stat(abs);
       if (!st.isFile()) return;
@@ -21062,7 +21118,7 @@ async function findSessionFileGlobFallback(sessionId) {
   return state2.best !== null ? state2.best.p : null;
 }
 async function loadLatestIndexEntriesBySessionId() {
-  const indexFile = path30.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path31.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   const map = /* @__PURE__ */ new Map();
   let raw;
   try {
@@ -21102,11 +21158,11 @@ function dateFolderFromRelativePath(relativePath) {
 async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs, opts) {
   let rel;
   try {
-    rel = path30.relative(getPreferredAppDir(), absPath);
+    rel = path31.relative(getPreferredAppDir(), absPath);
   } catch {
     rel = absPath;
   }
-  const dateFolder = dateFolderFromRelativePath(rel.split(path30.sep).join("/"));
+  const dateFolder = dateFolderFromRelativePath(rel.split(path31.sep).join("/"));
   let preview = opts?.preview ?? "(no messages)";
   let lastActivityMs = lastMtimeMs;
   if (opts?.updatedAtIso) {
@@ -21145,7 +21201,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 = path30.join(appDir, row.relativePath);
+    const full = path31.join(appDir, row.relativePath);
     try {
       const st = await fs28.stat(full);
       if (!st.isFile()) continue;
@@ -21158,9 +21214,9 @@ async function listAgentSessionsForResume(limit = 50) {
     } catch {
     }
   }
-  const sessionsRoot = path30.join(appDir, "sessions");
+  const sessionsRoot = path31.join(appDir, "sessions");
   await walkSessionJsonFiles2(sessionsRoot, async (absPath) => {
-    const id = path30.basename(absPath, ".json");
+    const id = path31.basename(absPath, ".json");
     if (!id) return;
     try {
       const st = await fs28.stat(absPath);
@@ -21175,7 +21231,7 @@ async function listAgentSessionsForResume(limit = 50) {
   const index = await loadLatestIndexEntriesBySessionId();
   for (const [sessionId, entry] of index) {
     if (map.has(sessionId)) continue;
-    const full = path30.join(appDir, entry.relativePath.replace(/\//g, path30.sep));
+    const full = path31.join(appDir, entry.relativePath.replace(/\//g, path31.sep));
     try {
       const st = await fs28.stat(full);
       if (st.isFile()) {
@@ -21234,7 +21290,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path31.dirname(dest);
+      const dir = path32.dirname(dest);
       await fs29.mkdir(dir, { recursive: true }).catch(() => {
       });
       await fs29.rename(src, dest);
@@ -21252,7 +21308,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   try {
     await fs29.access(src);
     const data = await fs29.readFile(src);
-    const dir = path31.dirname(dest);
+    const dir = path32.dirname(dest);
     await fs29.mkdir(dir, { recursive: true }).catch(() => {
     });
     await fs29.writeFile(dest, data);
@@ -21269,13 +21325,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path31.join(appDir, "sessions");
+  const sessionDir = path32.join(appDir, "sessions");
   await fs29.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function resolveAgentSessionFilePath(sessionId) {
   const appDir = getPreferredAppDir();
-  const legacy = path31.join(appDir, "sessions", `${sessionId}.json`);
+  const legacy = path32.join(appDir, "sessions", `${sessionId}.json`);
   try {
     await fs29.access(legacy);
     return legacy;
@@ -21283,7 +21339,7 @@ async function resolveAgentSessionFilePath(sessionId) {
   }
   const rel = await resolveSessionRelativePathFromIndex(sessionId);
   if (rel) {
-    const full = path31.join(appDir, rel);
+    const full = path32.join(appDir, rel);
     try {
       await fs29.access(full);
       return full;
@@ -21319,16 +21375,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 = path31.join(sessionsRoot, y, mo, d);
+  const datedDir = path32.join(sessionsRoot, y, mo, d);
   await fs29.mkdir(datedDir, { recursive: true });
-  const sessionFile = path31.join(datedDir, `${sessionId}.json`);
+  const sessionFile = path32.join(datedDir, `${sessionId}.json`);
   const newSessionData = {
     session_id: sessionId,
     created_at: now2.toISOString(),
     conversation_history: []
   };
   await fs29.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
-  const relToApp = path31.relative(getPreferredAppDir(), sessionFile);
+  const relToApp = path32.relative(getPreferredAppDir(), sessionFile);
   await appendAgentSessionPath(sessionId, relToApp);
   const emptyMemory = {
     historyAnchor: null,
@@ -21340,7 +21396,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path31.dirname(sessionFile);
+      const dir = path32.dirname(sessionFile);
       await fs29.mkdir(dir, { recursive: true });
     } catch {
     }
@@ -21356,7 +21412,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path31.basename(sessionFile, ".json");
+      const sessionId = path32.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -21381,12 +21437,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     try {
       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 sessionId = sessionData.session_id ?? path32.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);
+        relToApp = path32.relative(getPreferredAppDir(), sessionFile);
       } catch {
         relToApp = sessionFile;
       }
@@ -21439,12 +21495,12 @@ async function saveSessionHistoryNow(sessionFile, history, memory) {
 // src/app/agent/core/prompt/prompt_builder.ts
 import os24 from "os";
 import fs36 from "fs";
-import path38 from "path";
+import path39 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
 import fs30 from "fs";
-import path32 from "path";
+import path33 from "path";
 import os20 from "os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var SkillLoader = class _SkillLoader {
@@ -21454,8 +21510,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path32.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path32.join(os20.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path33.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path33.join(os20.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -21464,32 +21520,32 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path32.join(process.cwd(), "dist", "config", "skills");
+      return path33.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path32.resolve(p);
+      const abs = path33.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path32.dirname(fileURLToPath3(import.meta.url));
-      push(path32.join(bundleDir, "config", "skills"));
+      const bundleDir = path33.dirname(fileURLToPath3(import.meta.url));
+      push(path33.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path32.isAbsolute(argv1) && fs30.existsSync(argv1)) {
+        if (path33.isAbsolute(argv1) && fs30.existsSync(argv1)) {
           resolved = fs30.realpathSync(argv1);
-        } else if (!path32.isAbsolute(argv1)) {
-          resolved = path32.resolve(process.cwd(), argv1);
+        } else if (!path33.isAbsolute(argv1)) {
+          resolved = path33.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path32.dirname(resolved);
-        argvBundled = path32.join(scriptDir, "config", "skills");
+        const scriptDir = path33.dirname(resolved);
+        argvBundled = path33.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
@@ -21500,12 +21556,12 @@ var SkillLoader = class _SkillLoader {
       }
     }
     try {
-      return path32.join(path32.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
+      return path33.join(path33.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path32.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path33.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -21534,8 +21590,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path32.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path32.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path33.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path33.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -21546,9 +21602,9 @@ var SkillLoader = class _SkillLoader {
     if (!fs30.existsSync(dir)) return [];
     try {
       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);
+        const fullPath = path33.join(dir, d);
+        return fs30.statSync(fullPath).isDirectory() && fs30.existsSync(path33.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path33.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
@@ -21578,9 +21634,9 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    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 bundledPath = path33.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path33.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path33.join(this.globalSkillsDir, name, "SKILL.md");
     const existsBundled = fs30.existsSync(bundledPath);
     const existsProject = fs30.existsSync(projectPath);
     const existsGlobal = fs30.existsSync(globalPath);
@@ -21624,7 +21680,7 @@ var SkillLoader = class _SkillLoader {
     try {
       const raw = fs30.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path32.dirname(skillPath);
+      const skillDir = path33.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -21633,8 +21689,8 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path32.join(skillDir, "references")),
-        scripts: this.scanAssets(path32.join(skillDir, "scripts"))
+        references: this.scanAssets(path33.join(skillDir, "references")),
+        scripts: this.scanAssets(path33.join(skillDir, "scripts"))
       };
     } catch {
       return null;
@@ -21644,11 +21700,11 @@ var SkillLoader = class _SkillLoader {
     if (!fs30.existsSync(dir)) return [];
     try {
       return fs30.readdirSync(dir).filter((f) => {
-        const fp = path32.join(dir, f);
+        const fp = path33.join(dir, f);
         return fs30.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path32.resolve(dir, f)
+        path: path33.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -21705,9 +21761,9 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    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 bundledPath = path33.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path33.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path33.join(this.globalSkillsDir, name, "SKILL.md");
     return fs30.existsSync(bundledPath) || fs30.existsSync(projectPath) || fs30.existsSync(globalPath);
   }
   /**
@@ -21741,12 +21797,12 @@ var SkillLoader = class _SkillLoader {
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
 import fs32 from "fs";
-import path34 from "path";
+import path35 from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/app/agent/utils/blumamd.ts
 import fs31 from "fs";
-import path33 from "path";
+import path34 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.";
@@ -21876,12 +21932,12 @@ var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 function expandIncludePath(includePath, baseDir) {
   const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
   if (cleanPath.startsWith("~")) {
-    return path33.join(os21.homedir(), cleanPath.slice(1));
+    return path34.join(os21.homedir(), cleanPath.slice(1));
   }
-  if (path33.isAbsolute(cleanPath)) {
+  if (path34.isAbsolute(cleanPath)) {
     return cleanPath;
   }
-  return path33.resolve(baseDir, cleanPath);
+  return path34.resolve(baseDir, cleanPath);
 }
 function processIncludes(content, baseDir, processedFiles) {
   const lines = content.split("\n");
@@ -21890,12 +21946,12 @@ function processIncludes(content, baseDir, processedFiles) {
     const includeMatch = line.match(/^@\s*([^\s]+)/);
     if (includeMatch) {
       const includePath = expandIncludePath(includeMatch[1], baseDir);
-      const normalizedPath = path33.normalize(includePath);
+      const normalizedPath = path34.normalize(includePath);
       if (processedFiles.has(normalizedPath)) {
         result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
         continue;
       }
-      const ext = path33.extname(includePath).toLowerCase();
+      const ext = path34.extname(includePath).toLowerCase();
       if (!TEXT_FILE_EXTENSIONS.has(ext)) {
         result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
         continue;
@@ -21903,7 +21959,7 @@ function processIncludes(content, baseDir, processedFiles) {
       try {
         const includedContent = fs31.readFileSync(includePath, "utf-8");
         processedFiles.add(normalizedPath);
-        const processedContent = processIncludes(includedContent, path33.dirname(includePath), processedFiles);
+        const processedContent = processIncludes(includedContent, path34.dirname(includePath), processedFiles);
         result.push(`
 <!-- BEGIN INCLUDE ${includeMatch[1]} -->
 `);
@@ -21950,8 +22006,8 @@ function parseFrontmatterPaths(paths2) {
 function readMemoryFile(filePath, type, includeBasePath) {
   try {
     const rawContent = fs31.readFileSync(filePath, "utf-8");
-    const baseDir = includeBasePath || path33.dirname(filePath);
-    const processedFiles = /* @__PURE__ */ new Set([path33.normalize(filePath)]);
+    const baseDir = includeBasePath || path34.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path34.normalize(filePath)]);
     const { frontmatter, content: withoutFrontmatter } = parseFrontmatter(rawContent);
     const globs = parseFrontmatterPaths(frontmatter.paths);
     const processedContent = processIncludes(withoutFrontmatter, baseDir, processedFiles);
@@ -21973,15 +22029,15 @@ function readMemoryFile(filePath, type, includeBasePath) {
 }
 function findGitRoot(startDir) {
   let current = startDir;
-  while (current !== path33.dirname(current)) {
-    const gitPath = path33.join(current, ".git");
+  while (current !== path34.dirname(current)) {
+    const gitPath = path34.join(current, ".git");
     try {
       if (fs31.existsSync(gitPath)) {
         return current;
       }
     } catch {
     }
-    current = path33.dirname(current);
+    current = path34.dirname(current);
   }
   return null;
 }
@@ -22012,11 +22068,11 @@ function processRulesDirectory(rulesDir, type, processedPaths, conditionalRule =
   try {
     const entries = fs31.readdirSync(rulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path33.join(rulesDir, entry.name);
+      const entryPath = path34.join(rulesDir, entry.name);
       if (entry.isDirectory()) {
         result.push(...processRulesDirectory(entryPath, type, processedPaths, conditionalRule));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const normalizedPath = path33.normalize(entryPath);
+        const normalizedPath = path34.normalize(entryPath);
         if (processedPaths.has(normalizedPath)) {
           continue;
         }
@@ -22052,13 +22108,13 @@ function loadManagedMemory() {
 function loadUserMemory() {
   const files = [];
   const homeDir = os21.homedir();
-  const userBlumaDir = path33.join(homeDir, ".bluma");
-  const userBlumaMd = path33.join(userBlumaDir, "BLUMA.md");
+  const userBlumaDir = path34.join(homeDir, ".bluma");
+  const userBlumaMd = path34.join(userBlumaDir, "BLUMA.md");
   const userFile = readMemoryFile(userBlumaMd, "User");
   if (userFile && userFile.content.trim()) {
     files.push(userFile);
   }
-  const userRulesDir = path33.join(userBlumaDir, "rules");
+  const userRulesDir = path34.join(userBlumaDir, "rules");
   const processedPaths = /* @__PURE__ */ new Set();
   files.push(...processRulesDirectory(userRulesDir, "User", processedPaths, false));
   return files;
@@ -22070,10 +22126,10 @@ function loadProjectMemory(cwd2) {
   let currentDir = cwd2;
   const MAX_TRAVERSAL_DEPTH = 20;
   let depth = 0;
-  const normalizedGitRoot = path33.resolve(gitRoot);
-  while (currentDir !== path33.dirname(currentDir) && path33.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
+  const normalizedGitRoot = path34.resolve(gitRoot);
+  while (currentDir !== path34.dirname(currentDir) && path34.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
     dirs.push(currentDir);
-    currentDir = path33.dirname(currentDir);
+    currentDir = path34.dirname(currentDir);
     depth++;
   }
   if (!dirs.includes(gitRoot)) {
@@ -22081,7 +22137,7 @@ function loadProjectMemory(cwd2) {
   }
   const processedPaths = /* @__PURE__ */ new Set();
   for (const dir of dirs.reverse()) {
-    const projectBlumaMd = path33.join(dir, "BLUMA.md");
+    const projectBlumaMd = path34.join(dir, "BLUMA.md");
     if (!processedPaths.has(projectBlumaMd)) {
       processedPaths.add(projectBlumaMd);
       const projectFile = readMemoryFile(projectBlumaMd, "Project");
@@ -22089,7 +22145,7 @@ function loadProjectMemory(cwd2) {
         files.push(projectFile);
       }
     }
-    const blumaDirBlumaMd = path33.join(dir, ".bluma", "BLUMA.md");
+    const blumaDirBlumaMd = path34.join(dir, ".bluma", "BLUMA.md");
     if (!processedPaths.has(blumaDirBlumaMd)) {
       processedPaths.add(blumaDirBlumaMd);
       const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "Project");
@@ -22097,10 +22153,10 @@ function loadProjectMemory(cwd2) {
         files.push(blumaDirFile);
       }
     }
-    const rulesDir = path33.join(dir, ".bluma", "rules");
+    const rulesDir = path34.join(dir, ".bluma", "rules");
     files.push(...processRulesDirectory(rulesDir, "Project", processedPaths, false));
   }
-  const localBlumaMd = path33.join(cwd2, "BLUMA.local.md");
+  const localBlumaMd = path34.join(cwd2, "BLUMA.local.md");
   if (!processedPaths.has(localBlumaMd)) {
     processedPaths.add(localBlumaMd);
     const localFile = readMemoryFile(localBlumaMd, "Local");
@@ -22201,7 +22257,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd2) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path34.join(cwd2, name), LIMITS.readme);
+    const c = safeReadFile(path35.join(cwd2, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -22209,14 +22265,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd2) {
   const paths2 = [
-    path34.join(cwd2, "BluMa.md"),
-    path34.join(cwd2, "BLUMA.md"),
-    path34.join(cwd2, ".bluma", "BluMa.md")
+    path35.join(cwd2, "BluMa.md"),
+    path35.join(cwd2, "BLUMA.md"),
+    path35.join(cwd2, ".bluma", "BluMa.md")
   ];
   for (const p of paths2) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path34.relative(cwd2, p) || p;
+      const rel = path35.relative(cwd2, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -22224,7 +22280,7 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd2) {
-  const p = path34.join(cwd2, "package.json");
+  const p = path35.join(cwd2, "package.json");
   try {
     if (!fs32.existsSync(p)) return null;
     const pkg = JSON.parse(fs32.readFileSync(p, "utf8"));
@@ -22318,7 +22374,7 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path34.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path35.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -22336,15 +22392,15 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path34.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path35.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path34.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path35.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path34.join(cwd2, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path35.join(cwd2, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -22380,14 +22436,14 @@ function buildWorkspaceSnapshot(cwd2) {
   } else {
     parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
   }
-  const tsconfig = safeReadFile(path34.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
+  const tsconfig = safeReadFile(path35.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(path34.join(cwd2, name), LIMITS.dockerfile);
+    const df = safeReadFile(path35.join(cwd2, name), LIMITS.dockerfile);
     if (df) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22397,7 +22453,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const dc = safeReadFile(path34.join(cwd2, name), LIMITS.dockerfile);
+    const dc = safeReadFile(path35.join(cwd2, name), LIMITS.dockerfile);
     if (dc) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22412,7 +22468,7 @@ function buildWorkspaceSnapshot(cwd2) {
     ".circleci/config.yml",
     "Jenkinsfile"
   ]) {
-    const ciFile = path34.join(cwd2, ciPath);
+    const ciFile = path35.join(cwd2, ciPath);
     if (fs32.existsSync(ciFile)) {
       const st = fs32.statSync(ciFile);
       if (st.isDirectory()) {
@@ -22428,7 +22484,7 @@ function buildWorkspaceSnapshot(cwd2) {
       } else {
         const ci = safeReadFile(ciFile, LIMITS.ciConfig);
         if (ci) {
-          parts.push(`### CI config (${path34.basename(ciPath)})
+          parts.push(`### CI config (${path35.basename(ciPath)})
 `);
           parts.push(ci);
           parts.push("\n");
@@ -22437,7 +22493,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const depFile of ["requirements.txt", "Pipfile", "poetry.lock", "Gemfile", "go.sum", "Cargo.lock"]) {
-    const depPath = path34.join(cwd2, depFile);
+    const depPath = path35.join(cwd2, depFile);
     if (fs32.existsSync(depPath)) {
       const depContent = safeReadFile(depPath, 1500);
       if (depContent) {
@@ -22451,7 +22507,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
-    const envPath = path34.join(cwd2, envFile);
+    const envPath = path35.join(cwd2, envFile);
     if (fs32.existsSync(envPath)) {
       try {
         const raw = fs32.readFileSync(envPath, "utf-8");
@@ -22479,13 +22535,13 @@ init_runtime_config();
 init_sandbox_policy();
 import fs33 from "fs";
 import os22 from "os";
-import path35 from "path";
+import path36 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path35.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path36.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path35.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
+  return path36.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -22511,8 +22567,8 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path35.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path35.join(pluginDir, "plugin.json")
+    path36.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path36.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
     if (fs33.existsSync(candidate)) {
@@ -22526,7 +22582,7 @@ function listFromDir(baseDir, source) {
     return [];
   }
   return fs33.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path35.join(baseDir, entry.name);
+    const pluginDir = path36.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -22972,7 +23028,7 @@ function buildModelInfoSection(modelId) {
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
 import fs34 from "fs";
-import path36 from "path";
+import path37 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -22983,7 +23039,7 @@ var cache3 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path36.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path37.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -23029,7 +23085,7 @@ function ensureLoaded2() {
 }
 function persist2(state2) {
   const statePath = getStatePath();
-  fs34.mkdirSync(path36.dirname(statePath), { recursive: true });
+  fs34.mkdirSync(path37.dirname(statePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   fs34.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
   cache3 = state2;
@@ -23282,9 +23338,9 @@ Usa s\xF3 facts do pedido; campos em falta \u2192 "n\xE3o fornecido" \u2014 nunc
 
 // src/app/agent/core/prompt/auto_memory.ts
 import fs35 from "fs";
-import path37 from "path";
+import path38 from "path";
 import os23 from "os";
-var AUTO_MEMORY_FILE = path37.join(os23.homedir(), ".bluma", "auto_memory.md");
+var AUTO_MEMORY_FILE = path38.join(os23.homedir(), ".bluma", "auto_memory.md");
 var MAX_AUTO_MEMORY_CHARS = 25e3;
 var MAX_AUTO_MEMORY_LINES = 200;
 function getAutoMemoryForPrompt() {
@@ -23446,17 +23502,17 @@ function getGitBranch(dir) {
   }
 }
 function getPackageManager(dir) {
-  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";
+  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";
   return "unknown";
 }
 function getProjectType(dir) {
   try {
     const files = fs36.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs36.readFileSync(path38.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs36.readFileSync(path39.join(dir, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.next) return "Next.js";
       if (deps.react) return "React";
@@ -23476,7 +23532,7 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path38.join(dir, "package.json");
+    const pkgPath = path39.join(dir, "package.json");
     if (fs36.existsSync(pkgPath)) {
       const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -23487,7 +23543,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs36.existsSync(path38.join(dir, "pytest.ini")) || fs36.existsSync(path38.join(dir, "conftest.py"))) return "pytest";
+    if (fs36.existsSync(path39.join(dir, "pytest.ini")) || fs36.existsSync(path39.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -23495,7 +23551,7 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path38.join(dir, "package.json");
+    const pkgPath = path39.join(dir, "package.json");
     if (fs36.existsSync(pkgPath)) {
       const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return "npm test";
@@ -23512,7 +23568,7 @@ function getTestCommand(dir) {
 }
 function isGitRepo(dir) {
   try {
-    const p = path38.join(dir, ".git");
+    const p = path39.join(dir, ".git");
     return fs36.existsSync(p) && fs36.lstatSync(p).isDirectory();
   } catch {
     return false;
@@ -24936,7 +24992,7 @@ var LLMService = class {
 // src/app/agent/utils/user_message_images.ts
 import fs37 from "fs";
 import os26 from "os";
-import path39 from "path";
+import path40 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;
@@ -24952,22 +25008,22 @@ var MIME = {
 function expandUserPath(p) {
   const t = p.trim();
   if (t.startsWith("~")) {
-    return path39.join(os26.homedir(), t.slice(1).replace(/^\//, ""));
+    return path40.join(os26.homedir(), t.slice(1).replace(/^\//, ""));
   }
   return t;
 }
 function isPathAllowed(absResolved, cwd2) {
-  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);
+  const resolved = path40.normalize(path40.resolve(absResolved));
+  const cwdR = path40.normalize(path40.resolve(cwd2));
+  const homeR = path40.normalize(path40.resolve(os26.homedir()));
+  const tmpR = path40.normalize(path40.resolve(os26.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);
   return underCwd || underHome || underTmp;
 }
 function mimeFor(abs) {
-  const ext = path39.extname(abs).toLowerCase();
+  const ext = path40.extname(abs).toLowerCase();
   return MIME[ext] || "application/octet-stream";
 }
 var IMAGE_EXT_SRC = String.raw`(?:png|jpe?g|gif|webp|bmp)`;
@@ -25011,7 +25067,7 @@ function collectImagePathStrings(raw) {
 }
 function resolveImagePath(candidate, cwd2) {
   const expanded = expandUserPath(candidate);
-  const abs = path39.isAbsolute(expanded) ? path39.normalize(expanded) : path39.normalize(path39.resolve(cwd2, expanded));
+  const abs = path40.isAbsolute(expanded) ? path40.normalize(expanded) : path40.normalize(path40.resolve(cwd2, expanded));
   if (!isPathAllowed(abs, cwd2)) return null;
   try {
     if (!fs37.existsSync(abs) || !fs37.statSync(abs).isFile()) return null;
@@ -25034,7 +25090,7 @@ function trySingleLineFileUriOrBareImagePath(line, cwd2) {
   if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
     s = s.slice(1, -1).trim();
   }
-  if (!IMAGE_EXT.test(path39.extname(s))) return null;
+  if (!IMAGE_EXT.test(path40.extname(s))) return null;
   const abs = resolveImagePath(s, cwd2);
   if (!abs) return null;
   try {
@@ -25137,7 +25193,7 @@ function buildUserMessageContent(raw, cwd2) {
 init_sandbox_policy();
 init_runtime_config();
 init_permission_rules();
-import path40 from "path";
+import path41 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";
@@ -25152,11 +25208,11 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (!filePath) {
     return { allowed: false, reason: "No file path provided for permission check." };
   }
-  const resolvedPath = path40.resolve(filePath);
+  const resolvedPath = path41.resolve(filePath);
   if (!isPathInsideWorkspace(resolvedPath, policy)) {
     return { allowed: false, reason: `File path "${filePath}" is outside workspace root.` };
   }
-  const relativePath = path40.relative(policy.workspaceRoot, resolvedPath);
+  const relativePath = path41.relative(policy.workspaceRoot, resolvedPath);
   const toolPattern = `${toolName}(${relativePath})`;
   const ruleDecision = permissionRulesEngine.checkPermission(toolPattern, { filepath: filePath });
   if (ruleDecision === "deny") {
@@ -25165,7 +25221,7 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (ruleDecision === "allow") {
     return { allowed: true, reason: `File "${filePath}" allowed by permission rules.` };
   }
-  const dirPath = path40.dirname(relativePath);
+  const dirPath = path41.dirname(relativePath);
   const dirPattern = `${toolName}(${dirPath}/**)`;
   const dirRuleDecision = permissionRulesEngine.checkPermission(dirPattern, { filepath: filePath });
   if (dirRuleDecision === "allow") {
@@ -25383,10 +25439,10 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryConsolidate.ts
 import * as fs38 from "fs";
-import * as path41 from "path";
+import * as path42 from "path";
 import os27 from "os";
 function memoryPath2() {
-  return path41.join(process.env.HOME || os27.homedir(), ".bluma", "coding_memory.json");
+  return path42.join(process.env.HOME || os27.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -25947,16 +26003,16 @@ var BluMaToolRunner = class {
 };
 
 // src/app/agent/session_manager/session_archive.ts
-import path42 from "path";
+import path43 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);
+  const dir = path43.join(appDir, "sessions", "archive", sessionId);
   await fs39.mkdir(dir, { recursive: true });
-  const archiveFile = path42.join(dir, `${Date.now()}.jsonl`);
+  const archiveFile = path43.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;
@@ -26793,7 +26849,7 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     try {
       const sessionData = {
-        session_id: path43.basename(this.sessionFile, ".json"),
+        session_id: path44.basename(this.sessionFile, ".json"),
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: this.history,
         last_updated: (/* @__PURE__ */ new Date()).toISOString(),
@@ -27005,7 +27061,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path43.basename(toolArgs.file_path);
+      const filename = path44.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}`;
@@ -27733,14 +27789,14 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 // src/app/agent/core/memory/session_memory.ts
 import fs41 from "fs";
 import os30 from "os";
-import path44 from "path";
+import path45 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path44.join(os30.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path45.join(os30.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -28349,14 +28405,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path56, handler) {
-    this.routeHandlers.set(path56, handler);
+  registerRoute(path57, handler) {
+    this.routeHandlers.set(path57, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext, options } = payload;
-    for (const [path56, handler] of this.routeHandlers) {
-      if (inputText === path56 || inputText.startsWith(`${path56} `)) {
+    for (const [path57, handler] of this.routeHandlers) {
+      if (inputText === path57 || inputText.startsWith(`${path57} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -28365,13 +28421,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path45 from "path";
+import path46 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 = path45.resolve(p.root, entry);
+    const abs = path46.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -28392,7 +28448,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path46.join(os31.homedir(), ".bluma", ".env");
+var globalEnvPath = path47.join(os31.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -30248,10 +30304,10 @@ function resolveToolPayload(result) {
 
 // src/app/ui/components/FilePathLink.tsx
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import path48 from "node:path";
+import path49 from "node:path";
 
 // src/app/ui/utils/pathDisplay.ts
-import path47 from "node:path";
+import path48 from "node:path";
 import os32 from "node:os";
 function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
   let s = String(pathInput ?? "").trim();
@@ -30259,17 +30315,17 @@ function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
     s = s.replace(/[/\\]+$/, "");
   }
   if (!s) return "";
-  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)) {
+  const abs = path48.isAbsolute(s) ? path48.normalize(s) : path48.resolve(cwd2, s);
+  const resolvedCwd = path48.resolve(cwd2);
+  const rel = path48.relative(resolvedCwd, abs);
+  if (rel === "" || !rel.startsWith("..") && !path48.isAbsolute(rel)) {
     return rel === "" ? "." : rel;
   }
-  const home = path47.normalize(os32.homedir());
-  if (abs === home || abs.startsWith(home + path47.sep)) {
+  const home = path48.normalize(os32.homedir());
+  if (abs === home || abs.startsWith(home + path48.sep)) {
     return "~" + abs.slice(home.length);
   }
-  return path47.basename(abs);
+  return path48.basename(abs);
 }
 
 // src/app/ui/components/FilePathLink.tsx
@@ -30279,7 +30335,7 @@ function FilePathLink({ filePath, children, cwd: cwd2 = process.cwd(), color })
   if (!raw) {
     return null;
   }
-  const abs = path48.isAbsolute(raw) ? path48.normalize(raw) : path48.resolve(cwd2, raw);
+  const abs = path49.isAbsolute(raw) ? path49.normalize(raw) : path49.resolve(cwd2, raw);
   const href = pathToFileURL3(abs).href;
   const label = formatPathForDisplay(abs, cwd2);
   const text = typeof children === "string" ? children : label;
@@ -32914,13 +32970,13 @@ function EditToolDiffPanel({
   newString,
   replaceAll = false
 }) {
-  const path56 = filePath.trim() || "unknown file";
+  const path57 = 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: path56,
+      filePath: path57,
       oldString,
       newString,
       replaceAll,
@@ -32958,7 +33014,7 @@ function renderToolUseMessage12({ args }) {
   return /* @__PURE__ */ jsx44(Text, { color: BLUMA_TERMINAL.blue, children: p });
 }
 function renderToolHeader12({ args }) {
-  const path56 = args?.file_path ?? ".";
+  const path57 = 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);
@@ -32968,7 +33024,7 @@ function renderToolHeader12({ args }) {
       action,
       /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
         " ",
-        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path56, color: BLUMA_TERMINAL.dim })
+        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path57, color: BLUMA_TERMINAL.dim })
       ] })
     ] }),
     /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
@@ -33360,11 +33416,11 @@ function userFacingName13() {
 }
 function renderToolUseMessage14({ args }) {
   const q = args?.query ? `"${args.query}"` : "...";
-  const path56 = args?.path || ".";
+  const path57 = 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: path56, color: BLUMA_TERMINAL.dim })
+    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path57, color: BLUMA_TERMINAL.dim })
   ] });
 }
 function renderToolHeader14({ args }) {
@@ -36832,7 +36888,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 path49 from "path";
+import path50 from "path";
 var MAX_RESULTS3 = 50;
 var DEFAULT_RECURSIVE_DEPTH = 2;
 function listPathSuggestions(baseDir, pattern) {
@@ -36840,7 +36896,7 @@ function listPathSuggestions(baseDir, pattern) {
   const patternEndsWithSlash = raw.endsWith("/");
   const relDir = raw.replace(/^\/+|\/+$/g, "");
   const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
-  const listDir = path49.resolve(baseDir, relDir || ".");
+  const listDir = path50.resolve(baseDir, relDir || ".");
   const results = [];
   const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
   const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
@@ -36857,7 +36913,7 @@ function listPathSuggestions(baseDir, pattern) {
   }
   function pushEntry(entryPath, label, isDir) {
     if (results.length >= MAX_RESULTS3) return;
-    const clean = label.split(path49.sep).join("/").replace(/[]+/g, "");
+    const clean = label.split(path50.sep).join("/").replace(/[]+/g, "");
     results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
   }
   try {
@@ -36869,8 +36925,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 = path49.join(node.dir, entry.name);
-            const entryRel = node.rel ? path49.posix.join(node.rel, entry.name) : entry.name;
+            const entryAbs = path50.join(node.dir, entry.name);
+            const entryRel = node.rel ? path50.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());
@@ -36888,8 +36944,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 = path49.join(listDir, entry.name);
-        const label = relDir ? path49.posix.join(relDir, entry.name) : entry.name;
+        const entryAbs = path50.join(listDir, entry.name);
+        const label = relDir ? path50.posix.join(relDir, entry.name) : entry.name;
         pushEntry(entryAbs, label, entry.isDirectory());
         if (results.length >= MAX_RESULTS3) break;
       }
@@ -37092,7 +37148,7 @@ var SlashSubmenuInline = memo15(SlashSubmenuInlineComponent);
 // src/app/ui/utils/clipboardImage.ts
 import fs45 from "fs";
 import os33 from "os";
-import path50 from "path";
+import path51 from "path";
 import { spawn as spawn5, execFile as execFileCb, execSync as execSync4 } from "child_process";
 import { promisify as promisify2 } from "util";
 
@@ -37221,8 +37277,8 @@ function commandOnPath(cmd) {
 function unixClipboardHelperDirs() {
   const h = os33.homedir();
   return [
-    path50.join(h, ".local", "bin"),
-    path50.join(h, "bin"),
+    path51.join(h, ".local", "bin"),
+    path51.join(h, "bin"),
     "/usr/bin",
     "/usr/local/bin",
     "/bin",
@@ -37240,7 +37296,7 @@ function resolveHelperBinary(cmd) {
     return cmd;
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path50.join(dir, cmd);
+    const full = path51.join(dir, cmd);
     try {
       fs45.accessSync(full, fs45.constants.X_OK);
       return full;
@@ -37248,7 +37304,7 @@ function resolveHelperBinary(cmd) {
     }
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path50.join(dir, cmd);
+    const full = path51.join(dir, cmd);
     if (fs45.existsSync(full)) {
       return full;
     }
@@ -37290,7 +37346,7 @@ function writeBufferIfImage(baseDir, buf) {
   if (!ext) {
     return null;
   }
-  const out = path50.join(
+  const out = path51.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
@@ -37329,9 +37385,9 @@ async function tryDarwinClipboardy(baseDir) {
       if (st.size < 80 || st.size > CLIPBOARD_MAX_BYTES) {
         continue;
       }
-      const ext = path50.extname(src).toLowerCase();
+      const ext = path51.extname(src).toLowerCase();
       const safeExt = ext && /^\.(png|jpe?g|gif|webp)$/i.test(ext) ? ext : ".png";
-      const out = path50.join(
+      const out = path51.join(
         baseDir,
         `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${safeExt}`
       );
@@ -37349,7 +37405,7 @@ async function tryDarwinClipboardy(baseDir) {
   return null;
 }
 async function tryWindowsPowerShell(outFile) {
-  const ps = process.env.SystemRoot != null ? path50.join(
+  const ps = process.env.SystemRoot != null ? path51.join(
     process.env.SystemRoot,
     "System32",
     "WindowsPowerShell",
@@ -37450,8 +37506,8 @@ function parseClipboardTextAsImagePath(raw) {
     s = s.slice(1, -1);
   }
   s = s.trim();
-  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path50.extname(s))) return null;
-  const abs = path50.isAbsolute(s) ? path50.normalize(s) : path50.resolve(process.cwd(), s);
+  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path51.extname(s))) return null;
+  const abs = path51.isAbsolute(s) ? path51.normalize(s) : path51.resolve(process.cwd(), s);
   return abs;
 }
 async function tryClipboardTextAsImageFile(baseDir) {
@@ -37471,8 +37527,8 @@ async function tryClipboardTextAsImageFile(baseDir) {
   } catch {
     return null;
   }
-  const ext = path50.extname(abs).toLowerCase();
-  const out = path50.join(
+  const ext = path51.extname(abs).toLowerCase();
+  const out = path51.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
@@ -37487,7 +37543,7 @@ async function tryLinuxShellPipelineSave(baseDir) {
   if (process.platform !== "linux" && process.platform !== "freebsd") {
     return null;
   }
-  const outPath = path50.join(
+  const outPath = path51.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`
   );
@@ -37545,7 +37601,7 @@ async function tryNativeClipboardImage() {
   return null;
 }
 async function readClipboardImageToTempFile() {
-  const baseDir = path50.join(os33.homedir(), ".cache", "bluma", "clipboard");
+  const baseDir = path51.join(os33.homedir(), ".cache", "bluma", "clipboard");
   fs45.mkdirSync(baseDir, { recursive: true });
   const nativeResult = await tryNativeClipboardImage();
   if (nativeResult) {
@@ -37564,7 +37620,7 @@ async function readClipboardImageToTempFile() {
     }
   }
   if (process.platform === "win32") {
-    const outFile = path50.join(
+    const outFile = path51.join(
       baseDir,
       `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`
     );
@@ -40052,7 +40108,7 @@ var renderCode = () => {
 };
 
 // src/app/agent/core/thread/thread_store.ts
-import path51 from "path";
+import path52 from "path";
 import { promises as fs47 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 var INDEX_VERSION = 1;
@@ -40078,9 +40134,9 @@ var ThreadStore = class {
   packageVersion;
   constructor() {
     const appDir = getPreferredAppDir();
-    this.threadsDir = path51.join(appDir, "threads");
-    this.archiveDir = path51.join(this.threadsDir, "archive");
-    this.indexPath = path51.join(this.threadsDir, "index.json");
+    this.threadsDir = path52.join(appDir, "threads");
+    this.archiveDir = path52.join(this.threadsDir, "archive");
+    this.indexPath = path52.join(this.threadsDir, "index.json");
     this.packageVersion = process.env.npm_package_version || "0.0.0";
   }
   // ==================== Inicialização ====================
@@ -40202,7 +40258,7 @@ var ThreadStore = class {
       messages: params.initialMessages || []
     };
     const historyPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path51.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path52.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -40257,7 +40313,7 @@ var ThreadStore = class {
       compressedSliceCount: source.history.compressedSliceCount
     };
     const historyPath = this.buildDatedThreadHistoryPath(newThreadId);
-    await fs47.mkdir(path51.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path52.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -40330,7 +40386,7 @@ var ThreadStore = class {
     const entry = index.threads[entryIndex];
     if (entry.status === "archived") return true;
     const oldPath = entry.historyPath || this.getLegacyHistoryPath(threadId);
-    const newPath = path51.join(this.archiveDir, `${threadId}.jsonl`);
+    const newPath = path52.join(this.archiveDir, `${threadId}.jsonl`);
     try {
       await fs47.rename(oldPath, newPath);
     } catch (e) {
@@ -40353,9 +40409,9 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     if (entry.status === "active") return true;
-    const oldPath = path51.join(this.archiveDir, `${threadId}.jsonl`);
+    const oldPath = path52.join(this.archiveDir, `${threadId}.jsonl`);
     const newPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path51.dirname(newPath), { recursive: true });
+    await fs47.mkdir(path52.dirname(newPath), { recursive: true });
     try {
       await fs47.rename(oldPath, newPath);
     } catch (e) {
@@ -40388,14 +40444,14 @@ var ThreadStore = class {
   }
   // ==================== Histórico ====================
   getLegacyHistoryPath(threadId) {
-    return path51.join(this.threadsDir, `${threadId}.jsonl`);
+    return path52.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 path51.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
+    return path52.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
   }
   async resolveHistoryPath(threadId) {
     const index = await this.loadIndex();
@@ -40426,7 +40482,7 @@ var ThreadStore = class {
     for (const msg of history.messages) {
       lines.push(JSON.stringify({ type: "message", ...msg }));
     }
-    await fs47.mkdir(path51.dirname(historyPath), { recursive: true }).catch(() => {
+    await fs47.mkdir(path52.dirname(historyPath), { recursive: true }).catch(() => {
     });
     await fs47.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
   }
@@ -43358,13 +43414,13 @@ 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 path52 from "path";
+import path53 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 = path52.join(dir, "package.json");
+    const candidate = path53.join(dir, "package.json");
     if (fs48.existsSync(candidate)) {
       try {
         const raw = fs48.readFileSync(candidate, "utf8");
@@ -43375,7 +43431,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path52.dirname(dir);
+    const parent = path53.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -43384,13 +43440,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path52.resolve(dir);
+    const abs = path53.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path52.dirname(fileURLToPath6(import.meta.url)));
+    const fromBundle = tryFrom(path53.dirname(fileURLToPath6(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -43398,12 +43454,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path52.isAbsolute(argv1) && fs48.existsSync(argv1)) {
+      if (path53.isAbsolute(argv1) && fs48.existsSync(argv1)) {
         resolved = fs48.realpathSync(argv1);
       } else {
-        resolved = path52.resolve(process.cwd(), argv1);
+        resolved = path53.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path52.dirname(resolved));
+      const fromArgv = tryFrom(path53.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -44223,9 +44279,9 @@ function usePlanMode() {
 // src/app/hooks/useAgentMode.ts
 import { useState as useState22, useEffect as useEffect21, useCallback as useCallback9 } from "react";
 import * as fs49 from "fs";
-import * as path53 from "path";
+import * as path54 from "path";
 import { homedir as homedir3 } from "os";
-var SETTINGS_PATH = path53.join(homedir3(), ".bluma", "settings.json");
+var SETTINGS_PATH = path54.join(homedir3(), ".bluma", "settings.json");
 function readAgentModeFromFile() {
   try {
     if (!fs49.existsSync(SETTINGS_PATH)) {
@@ -44251,7 +44307,7 @@ function useAgentMode() {
   const updateAgentMode = useCallback9((mode) => {
     try {
       if (!fs49.existsSync(SETTINGS_PATH)) {
-        fs49.mkdirSync(path53.dirname(SETTINGS_PATH), { recursive: true });
+        fs49.mkdirSync(path54.dirname(SETTINGS_PATH), { recursive: true });
       }
       let settings = {};
       if (fs49.existsSync(SETTINGS_PATH)) {
@@ -45522,10 +45578,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 path54 from "path";
+import path55 from "path";
 import { promises as fs50 } from "fs";
 function getSessionsRoot() {
-  return path54.join(getPreferredAppDir(), "sessions");
+  return path55.join(getPreferredAppDir(), "sessions");
 }
 function normalizeSessionsCwd(cwd2) {
   return cwd2.replace(/\\/g, "/").split("/").filter((p) => p && p !== "." && p !== "..").join("/");
@@ -45576,7 +45632,7 @@ function compareDirNames(a, b) {
 async function listSessionBrowserEntries(cwdRel) {
   const cwd2 = normalizeSessionsCwd(cwdRel);
   const root = getSessionsRoot();
-  const absDir = cwd2 ? path54.join(root, ...cwd2.split("/")) : root;
+  const absDir = cwd2 ? path55.join(root, ...cwd2.split("/")) : root;
   const out = [];
   if (cwd2) {
     out.push({ kind: "up", label: ".." });
@@ -45593,7 +45649,7 @@ async function listSessionBrowserEntries(cwdRel) {
   for (const e of dirents) {
     const name = String(e.name);
     if (name.startsWith(".")) continue;
-    const full = path54.join(absDir, name);
+    const full = path55.join(absDir, name);
     if (e.isDirectory()) {
       dirNames.push(name);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -45603,7 +45659,7 @@ async function listSessionBrowserEntries(cwdRel) {
   dirNames.sort(compareDirNames);
   const sessions = [];
   for (const { name, full } of sessionFiles) {
-    const sessionId = path54.basename(name, ".json");
+    const sessionId = path55.basename(name, ".json");
     sessions.push(await sessionEntryFromFile(full, sessionId));
   }
   sessions.sort((a, b) => {
@@ -46211,8 +46267,8 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path55.dirname(fileURLToPath7(import.meta.url));
-    const pkgPath = path55.join(base, "..", "package.json");
+    const base = path56.dirname(fileURLToPath7(import.meta.url));
+    const pkgPath = path56.join(base, "..", "package.json");
     const j = JSON.parse(fs51.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {