@nomad-e/bluma-cli 0.1.71 → 0.1.72

package/dist/main.js

@@ -1737,8 +1737,8 @@ var init_themes = __esm({
 import React19 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter4 } from "events";
-import fs38 from "fs";
-import path43 from "path";
+import fs39 from "fs";
+import path44 from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
@@ -4438,12 +4438,12 @@ function EditToolDiffPanel({
   maxHeight = EDIT_DIFF_PREVIEW_MAX_LINES,
   fallbackSnippet
 }) {
-  const path44 = filePath.trim() || "unknown file";
+  const path45 = filePath.trim() || "unknown file";
   const diff = diffText?.trim() ?? "";
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx5(Box5, { flexDirection: "row", flexWrap: "wrap", children: /* @__PURE__ */ jsxs5(Text5, { color: isNewFile ? BLUMA_TERMINAL.success : void 0, children: [
       isNewFile ? "Created " : "Wrote to ",
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: path44 })
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: path45 })
     ] }) }),
     description ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, wrap: "wrap", children: description }) : null,
     diff.length > 0 ? /* @__PURE__ */ jsx5(Box5, { marginTop: 0, children: /* @__PURE__ */ jsx5(SimpleDiff, { text: diff, maxHeight, frame: true }) }) : fallbackSnippet ? /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 0, children: [
@@ -4772,7 +4772,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path44 = parsed.path || ".";
+  const path45 = parsed.path || ".";
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", flexWrap: "wrap", children: [
     /* @__PURE__ */ jsxs8(Text8, { color: BLUMA_TERMINAL.muted, children: [
       '"',
@@ -4781,7 +4781,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs8(Text8, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, children: [
       " ",
-      path44
+      path45
     ] })
   ] });
 };
@@ -5207,12 +5207,12 @@ var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path41 from "path";
+import path42 from "path";
 import os28 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs25 } from "fs";
-import path27 from "path";
+import { promises as fs26 } from "fs";
+import path28 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/app/agent/tools/natives/edit.ts
@@ -10308,19 +10308,86 @@ async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
     }
     const data = response.data || {};
     const resolvedAppId = appId || data.appId;
+    const appContext = data.appContext ? {
+      appId: String(data.appContext.appId || resolvedAppId || "").trim(),
+      tenantId: data.appContext.tenantId ?? null,
+      projectId: data.appContext.projectId ?? null,
+      workspaceId: data.appContext.workspaceId ?? null,
+      revisionId: data.appContext.revisionId ?? null,
+      deploymentId: data.appContext.deploymentId ?? null,
+      buildJobId: data.appContext.buildJobId ?? null,
+      manifestPath: data.appContext.manifestPath ?? "factorai.sh.json",
+      manifestFile: data.appContext.manifestFile ?? "factorai.sh.json",
+      appUrl: data.appContext.appUrl ?? `${severinoUrl.replace(/\/$/, "")}/app/${resolvedAppId}`
+    } : {
+      appId: String(resolvedAppId || "").trim(),
+      tenantId: data.tenantId ?? null,
+      projectId: data.projectId ?? null,
+      workspaceId: data.workspaceId ?? null,
+      revisionId: data.revisionId ?? null,
+      deploymentId: data.deploymentId ?? null,
+      buildJobId: data.buildJobId ?? null,
+      manifestPath: "factorai.sh.json",
+      manifestFile: "factorai.sh.json",
+      appUrl: `${severinoUrl.replace(/\/$/, "")}/app/${resolvedAppId}`
+    };
     return {
       success: true,
       appId: resolvedAppId,
       name: data.name,
       status: data.status || "building",
-      url: severinoUrl.replace(/\/$/, "") + `/app/${resolvedAppId}`,
+      url: appContext.appUrl || severinoUrl.replace(/\/$/, "") + `/app/${resolvedAppId}`,
       message: data.message || "Deploy iniciado",
-      isRedeploy: !!appId
+      isRedeploy: !!appId,
+      appContext
     };
   } catch (parseError) {
     throw new Error(`Failed to parse response: ${parseError.message}`);
   }
 }
+function buildFactorAiManifest(appContext, deployResult, appName) {
+  return {
+    version: 1,
+    manifestFile: "factorai.sh.json",
+    manifestPath: "factorai.sh.json",
+    appContext: {
+      appId: appContext.appId,
+      tenantId: appContext.tenantId ?? null,
+      projectId: appContext.projectId ?? null,
+      workspaceId: appContext.workspaceId ?? null,
+      revisionId: appContext.revisionId ?? null,
+      deploymentId: appContext.deploymentId ?? null,
+      buildJobId: appContext.buildJobId ?? null,
+      manifestPath: "factorai.sh.json",
+      manifestFile: "factorai.sh.json",
+      appUrl: appContext.appUrl ?? deployResult.url ?? null
+    },
+    app: {
+      name: appName,
+      status: deployResult.status || "building",
+      isRedeploy: deployResult.isRedeploy ?? false,
+      url: deployResult.url || null,
+      message: deployResult.message || null
+    },
+    agent: {
+      provider: "bluma",
+      mode: "tool-first",
+      instructions: [
+        "Read factorai.sh.json as the source of truth before editing files.",
+        "Prefer incremental changes and preserve the existing deployment context.",
+        "After edits, use the redeploy tool instead of rebuilding from scratch."
+      ]
+    },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function writeFactorAiManifest(projectDir, appContext, deployResult, appName) {
+  const manifest = buildFactorAiManifest(appContext, deployResult, appName);
+  const manifestPath = path26.join(projectDir, "factorai.sh.json");
+  await fs24.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+  return manifest;
+}
 async function deployApp(args) {
   const envSeverinoUrl = process.env.SEVERINO_URL || "http://localhost:3000";
   const envApiKey = process.env.SEVERINO_API_KEY || void 0;
@@ -10390,6 +10457,16 @@ async function deployApp(args) {
       console.warn("[deploy-app] Cleanup warning:", e);
     }
     if (deployResult.success) {
+      if (deployResult.appContext) {
+        const manifest = await writeFactorAiManifest(
+          resolvedProjectDir,
+          deployResult.appContext,
+          deployResult,
+          appName
+        );
+        deployResult.factoraiManifest = manifest;
+        deployResult.factoraiManifestPath = path26.join(resolvedProjectDir, "factorai.sh.json");
+      }
       console.log(`[deploy-app] Deploy iniciado: ${deployResult.appId}`);
     }
     return deployResult;
@@ -10402,8 +10479,389 @@ async function deployApp(args) {
   }
 }
 
+// src/app/agent/runtime/factorai_context.ts
+import fs25 from "fs";
+import path27 from "path";
+function normalizeContext(raw) {
+  if (!raw || typeof raw.appId !== "string" || !raw.appId.trim()) {
+    return null;
+  }
+  const appId = raw.appId.trim();
+  return {
+    appId,
+    tenantId: typeof raw.tenantId === "string" ? raw.tenantId : null,
+    projectId: typeof raw.projectId === "string" ? raw.projectId : null,
+    workspaceId: typeof raw.workspaceId === "string" ? raw.workspaceId : null,
+    revisionId: typeof raw.revisionId === "string" ? raw.revisionId : null,
+    deploymentId: typeof raw.deploymentId === "string" ? raw.deploymentId : null,
+    buildJobId: typeof raw.buildJobId === "string" ? raw.buildJobId : null,
+    manifestPath: typeof raw.manifestPath === "string" ? raw.manifestPath : null,
+    manifestFile: typeof raw.manifestFile === "string" ? raw.manifestFile : null,
+    appUrl: typeof raw.appUrl === "string" ? raw.appUrl : null
+  };
+}
+function readJsonFile(filePath) {
+  try {
+    if (!fs25.existsSync(filePath)) {
+      return null;
+    }
+    const parsed = JSON.parse(fs25.readFileSync(filePath, "utf8"));
+    if (parsed && typeof parsed === "object") {
+      return parsed.appContext && typeof parsed.appContext === "object" ? parsed.appContext : parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readFactorAiWorkspaceManifest(projectDir = process.cwd()) {
+  const manifestPath = path27.join(projectDir, "factorai.sh.json");
+  try {
+    if (!fs25.existsSync(manifestPath)) {
+      return null;
+    }
+    const parsed = JSON.parse(fs25.readFileSync(manifestPath, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readContextFromWorkspace() {
+  const candidate = path27.join(process.cwd(), "factorai.sh.json");
+  const parsed = readJsonFile(candidate);
+  if (!parsed) {
+    return null;
+  }
+  const context = normalizeContext(parsed);
+  return context;
+}
+function loadFactorAiAppContext() {
+  return readContextFromWorkspace();
+}
+function formatFactorAiAppContextSummary(context) {
+  if (!context) {
+    return "";
+  }
+  const parts = [
+    `appId=${context.appId}`,
+    context.tenantId ? `tenantId=${context.tenantId}` : null,
+    context.projectId ? `projectId=${context.projectId}` : null,
+    context.workspaceId ? `workspaceId=${context.workspaceId}` : null,
+    context.revisionId ? `revisionId=${context.revisionId}` : null,
+    context.deploymentId ? `deploymentId=${context.deploymentId}` : null,
+    context.buildJobId ? `buildJobId=${context.buildJobId}` : null,
+    context.appUrl ? `appUrl=${context.appUrl}` : null
+  ].filter(Boolean);
+  return parts.join(" | ");
+}
+function buildFactorAiWorkspaceManifest(input) {
+  const projectDir = input.projectDir || process.cwd();
+  const existing = readFactorAiWorkspaceManifest(projectDir) || {};
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const nextAppContext = {
+    ...typeof existing.appContext === "object" && existing.appContext ? existing.appContext : {},
+    appId: input.appContext.appId,
+    tenantId: input.appContext.tenantId ?? null,
+    projectId: input.appContext.projectId ?? null,
+    workspaceId: input.appContext.workspaceId ?? null,
+    revisionId: input.appContext.revisionId ?? null,
+    deploymentId: input.appContext.deploymentId ?? null,
+    buildJobId: input.appContext.buildJobId ?? null,
+    manifestPath: "factorai.sh.json",
+    manifestFile: "factorai.sh.json",
+    appUrl: input.appContext.appUrl ?? null
+  };
+  return {
+    ...existing,
+    version: 1,
+    manifestFile: "factorai.sh.json",
+    manifestPath: "factorai.sh.json",
+    appContext: nextAppContext,
+    app: {
+      ...typeof existing.app === "object" && existing.app ? existing.app : {},
+      name: input.name ?? (typeof existing.app === "object" && existing.app ? existing.app.name : void 0) ?? null,
+      status: input.status ?? (typeof existing.app === "object" && existing.app ? existing.app.status : void 0) ?? "building",
+      isRedeploy: input.isRedeploy ?? (typeof existing.app === "object" && existing.app ? existing.app.isRedeploy : false),
+      message: input.message ?? (typeof existing.app === "object" && existing.app ? existing.app.message : null),
+      ...input.app || {}
+    },
+    agent: {
+      provider: "bluma",
+      mode: "tool-first",
+      instructions: [
+        "Read factorai.sh.json as the source of truth before editing files.",
+        "Prefer incremental changes and preserve the existing deployment context.",
+        "After edits, use the redeploy tool instead of rebuilding from scratch."
+      ],
+      ...typeof existing.agent === "object" && existing.agent ? existing.agent : {},
+      ...input.agent || {}
+    },
+    sandbox: {
+      ...typeof existing.sandbox === "object" && existing.sandbox ? existing.sandbox : {},
+      ...input.sandbox || {}
+    },
+    source: {
+      root: ".",
+      publicDir: "./public",
+      appDir: ".",
+      ...typeof existing.source === "object" && existing.source ? existing.source : {},
+      ...input.source || {}
+    },
+    updatedAt: now2,
+    ...input.extra || {}
+  };
+}
+async function writeFactorAiWorkspaceManifest(input) {
+  const projectDir = input.projectDir || process.cwd();
+  const manifest = buildFactorAiWorkspaceManifest({ ...input, projectDir });
+  const manifestPath = path27.join(projectDir, "factorai.sh.json");
+  fs25.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  return { manifestPath, manifest };
+}
+
 // src/app/agent/runtime/native_tool_catalog.ts
 init_sandbox_policy();
+function getFactorAiBaseUrl() {
+  const value = process.env.FACTORAI_BASE_URL || process.env.FACTORAI_URL || "";
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function getFactorAiApiKey() {
+  const value = process.env.FACTORAI_API_KEY || process.env.FACTORAI_TOKEN || "";
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function isFactorAiSandboxEnabled() {
+  const policy = getSandboxPolicy();
+  return policy.isSandbox && Boolean(getFactorAiBaseUrl());
+}
+async function requestFactorAi(pathname, init = {}) {
+  const baseUrl = getFactorAiBaseUrl();
+  if (!baseUrl) {
+    throw new Error("FACTORAI_BASE_URL is not configured.");
+  }
+  const headers = new Headers(init.headers || {});
+  headers.set("Content-Type", "application/json");
+  const apiKey = getFactorAiApiKey();
+  if (apiKey) {
+    headers.set("Authorization", `Bearer ${apiKey}`);
+  }
+  const response = await fetch(new URL(pathname, baseUrl), {
+    ...init,
+    headers
+  });
+  const text = await response.text();
+  let payload = null;
+  if (text) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = text;
+    }
+  }
+  if (!response.ok) {
+    const message2 = payload?.error?.message || payload?.message || payload?.error || `FactorAI request failed with status ${response.status}`;
+    throw new Error(message2);
+  }
+  return payload;
+}
+async function factorAiGetAppStatus(args) {
+  const appId = String(args?.appId || "").trim();
+  if (!appId) {
+    return { error: "appId is required." };
+  }
+  return requestFactorAi(`/api/v1/apps/${encodeURIComponent(appId)}`);
+}
+async function factorAiApplyAppChanges(args) {
+  const appId = String(args?.appId || "").trim();
+  if (!appId) {
+    return { error: "appId is required." };
+  }
+  const files = Array.isArray(args?.files) ? args.files : Array.isArray(args?.changes) ? args.changes : [];
+  if (files.length === 0) {
+    return { error: "files or changes must be a non-empty array." };
+  }
+  const response = await requestFactorAi(`/api/v1/apps/${encodeURIComponent(appId)}/changes`, {
+    method: "POST",
+    body: JSON.stringify({
+      files,
+      deploy: args?.deploy !== false
+    })
+  });
+  await persistFactorAiWorkspaceManifestFromResponse(response);
+  return response;
+}
+async function factorAiRedeployApp(args) {
+  const appId = String(args?.appId || "").trim();
+  if (!appId) {
+    return { error: "appId is required." };
+  }
+  const response = await requestFactorAi(`/api/v1/apps/${encodeURIComponent(appId)}/redeploy`, {
+    method: "POST"
+  });
+  await persistFactorAiWorkspaceManifestFromResponse(response);
+  return response;
+}
+function extractFactorAiResponseData(response) {
+  if (response && typeof response === "object" && response.data && typeof response.data === "object") {
+    return response.data;
+  }
+  return response;
+}
+async function persistFactorAiWorkspaceManifestFromResponse(response) {
+  const data = extractFactorAiResponseData(response);
+  const appContext = data?.appContext;
+  if (!appContext || typeof appContext.appId !== "string" || !appContext.appId.trim()) {
+    return;
+  }
+  await writeFactorAiWorkspaceManifest({
+    projectDir: process.cwd(),
+    appContext: {
+      appId: String(appContext.appId).trim(),
+      tenantId: appContext.tenantId ?? null,
+      projectId: appContext.projectId ?? null,
+      workspaceId: appContext.workspaceId ?? null,
+      revisionId: appContext.revisionId ?? null,
+      deploymentId: appContext.deploymentId ?? null,
+      buildJobId: appContext.buildJobId ?? null,
+      manifestPath: appContext.manifestPath ?? appContext.manifestFile ?? "factorai.sh.json",
+      manifestFile: appContext.manifestFile ?? appContext.manifestPath ?? "factorai.sh.json",
+      appUrl: appContext.appUrl ?? data?.url ?? null
+    },
+    name: data?.name ?? data?.app?.name ?? void 0,
+    status: data?.status ?? "building",
+    isRedeploy: Boolean(data?.isRedeploy),
+    message: typeof data?.message === "string" ? data.message : null,
+    app: {
+      ...typeof data?.app === "object" && data.app ? data.app : {},
+      url: data?.url ?? data?.app?.url ?? null
+    },
+    agent: typeof data?.agent === "object" && data.agent ? data.agent : void 0,
+    sandbox: typeof data?.sandbox === "object" && data.sandbox ? data.sandbox : void 0,
+    source: typeof data?.source === "object" && data.source ? data.source : void 0,
+    extra: {
+      lastUpdatedFromTool: "factorai.sh.apply_app_changes"
+    }
+  });
+}
+function getFactorAiSandboxToolDefinitions() {
+  if (!isFactorAiSandboxEnabled()) {
+    return [];
+  }
+  return [
+    {
+      type: "function",
+      function: {
+        name: "factorai.sh.create_next_app",
+        description: "Create a new Next.js project in the sandbox workspace for FactorAI deployments.",
+        parameters: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Project name." },
+            template: { type: "string", enum: ["minimal", "full"], description: "Project template." },
+            directory: { type: "string", description: "Target directory for the project." }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "factorai.sh.deploy_app",
+        description: "Deploy a Next.js project from the sandbox to the FactorAI hosting backend. The returned metadata must be written into factorai.sh.json in the project root for future incremental edits.",
+        parameters: {
+          type: "object",
+          properties: {
+            projectDir: { type: "string", description: "Path to the Next.js project." },
+            name: { type: "string", description: "App name." },
+            severinoUrl: { type: "string", description: "Optional explicit backend URL." },
+            apiKey: { type: "string", description: "Optional explicit API key." }
+          },
+          required: ["projectDir"],
+          additionalProperties: false
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "factorai.sh.get_app_status",
+        description: "Get the current status and contract for a FactorAI deployment in the sandbox.",
+        parameters: {
+          type: "object",
+          properties: {
+            appId: { type: "string", description: "FactorAI app identifier." }
+          },
+          required: ["appId"],
+          additionalProperties: false
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "factorai.sh.apply_app_changes",
+        description: "Apply incremental file changes to a FactorAI workspace and optionally redeploy.",
+        parameters: {
+          type: "object",
+          properties: {
+            appId: { type: "string", description: "FactorAI app identifier." },
+            files: {
+              type: "array",
+              description: "List of changed files to apply.",
+              items: {
+                type: "object",
+                properties: {
+                  path: { type: "string" },
+                  content: { type: "string" }
+                },
+                required: ["path", "content"],
+                additionalProperties: false
+              }
+            },
+            changes: {
+              type: "array",
+              description: "Alias for files.",
+              items: {
+                type: "object",
+                properties: {
+                  path: { type: "string" },
+                  content: { type: "string" }
+                },
+                required: ["path", "content"],
+                additionalProperties: false
+              }
+            },
+            deploy: {
+              type: "boolean",
+              description: "Redeploy after applying changes. Defaults to true."
+            }
+          },
+          required: ["appId"],
+          additionalProperties: false
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "factorai.sh.redeploy_app",
+        description: "Redeploy the current revision of a FactorAI app.",
+        parameters: {
+          type: "object",
+          properties: {
+            appId: { type: "string", description: "FactorAI app identifier." }
+          },
+          required: ["appId"],
+          additionalProperties: false
+        }
+      }
+    }
+  ];
+}
 var NATIVE_TOOL_ENTRIES = [
   {
     metadata: {
@@ -10970,25 +11428,63 @@ var NATIVE_TOOL_ENTRIES = [
   },
   {
     metadata: {
-      name: "create_next_app",
+      name: "factorai.sh.create_next_app",
       category: "filesystem",
       riskLevel: "write",
       autoApproveInLocal: false,
       autoApproveInSandbox: true,
+      sandboxOnly: true,
       description: "Create a new Next.js project instantly with App Router, shadcn/ui components, Tailwind CSS, and TypeScript. Templates: minimal (basic structure) or full (with pre-built UI components)."
     },
     implementation: createNextApp
   },
   {
     metadata: {
-      name: "deploy_app",
+      name: "factorai.sh.deploy_app",
       category: "execution",
       riskLevel: "network",
       autoApproveInLocal: false,
       autoApproveInSandbox: true,
+      sandboxOnly: true,
       description: "Deploy a Next.js project to Severino. Zips the project (excluding node_modules, .next) and uploads to /api/v1/deploy. Returns appId and live URL."
     },
     implementation: deployApp
+  },
+  {
+    metadata: {
+      name: "factorai.sh.get_app_status",
+      category: "knowledge",
+      riskLevel: "network",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      sandboxOnly: true,
+      description: "Sandbox-only FactorAI tool. Fetch app status and sandbox contract from the deployed backend."
+    },
+    implementation: factorAiGetAppStatus
+  },
+  {
+    metadata: {
+      name: "factorai.sh.apply_app_changes",
+      category: "filesystem",
+      riskLevel: "write",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      sandboxOnly: true,
+      description: "Sandbox-only FactorAI tool. Apply file changes to a deployed app workspace and redeploy it."
+    },
+    implementation: factorAiApplyAppChanges
+  },
+  {
+    metadata: {
+      name: "factorai.sh.redeploy_app",
+      category: "execution",
+      riskLevel: "network",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      sandboxOnly: true,
+      description: "Sandbox-only FactorAI tool. Trigger redeploy for the current app revision."
+    },
+    implementation: factorAiRedeployApp
   }
 ];
 var TOOL_METADATA_MAP = new Map(
@@ -11004,11 +11500,10 @@ function getNativeToolImplementation(toolName) {
   return TOOL_IMPLEMENTATION_MAP.get(toolName);
 }
 function getAllNativeToolMetadata() {
-  const policy = getSandboxPolicy();
-  if (!policy.isSandbox) {
-    return NATIVE_TOOL_ENTRIES.filter((entry) => entry.metadata.autoApproveInLocal !== false || !["create_next_app", "deploy_app"].includes(entry.metadata.name)).map((entry) => entry.metadata);
-  }
-  return NATIVE_TOOL_ENTRIES.map((entry) => entry.metadata);
+  return NATIVE_TOOL_ENTRIES.filter((entry) => !entry.metadata.sandboxOnly || isFactorAiSandboxEnabled()).map((entry) => entry.metadata);
+}
+function getSandboxOnlyNativeToolDefinitions() {
+  return getFactorAiSandboxToolDefinitions();
 }
 function applyMetadataToToolDefinitions(toolDefinitions) {
   return toolDefinitions.map((definition) => {
@@ -11032,12 +11527,14 @@ var ToolInvoker = class {
    */
   async initialize() {
     try {
-      const __filename = fileURLToPath2(import.meta.url);
-      const __dirname = path27.dirname(__filename);
-      const configPath = path27.resolve(__dirname, "config", "native_tools.json");
-      const fileContent = await fs25.readFile(configPath, "utf-8");
+      const currentFilePath = fileURLToPath2(import.meta.url);
+      const currentDirPath = path28.dirname(currentFilePath);
+      const configPath = path28.resolve(currentDirPath, "config", "native_tools.json");
+      const fileContent = await fs26.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = applyMetadataToToolDefinitions(config2.nativeTools);
+      const sandboxOnlyTools = applyMetadataToToolDefinitions(getSandboxOnlyNativeToolDefinitions());
+      this.toolDefinitions.push(...sandboxOnlyTools);
     } catch (error) {
       console.error("[ToolInvoker] Erro cr\xEDtico ao carregar 'native_tools.json'. As ferramentas nativas n\xE3o estar\xE3o dispon\xEDveis.", error);
       this.toolDefinitions = [];
@@ -11077,8 +11574,8 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs26 } from "fs";
-import path28 from "path";
+import { promises as fs27 } from "fs";
+import path29 from "path";
 import os16 from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -11106,9 +11603,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath3(import.meta.url);
-    const __dirname = path28.dirname(__filename);
-    const defaultConfigPath = path28.resolve(__dirname, "config", "bluma-mcp.json");
-    const userConfigPath = path28.join(os16.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname = path29.dirname(__filename);
+    const defaultConfigPath = path29.resolve(__dirname, "config", "bluma-mcp.json");
+    const userConfigPath = path29.join(os16.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -11142,7 +11639,7 @@ var MCPClient = class {
   }
   async loadMcpConfig(configPath, configType) {
     try {
-      const fileContent = await fs26.readFile(configPath, "utf-8");
+      const fileContent = await fs27.readFile(configPath, "utf-8");
       const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
@@ -11319,13 +11816,13 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path38 from "path";
+import path39 from "path";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path29 from "path";
+import path30 from "path";
 import os17 from "os";
-import { promises as fs27 } from "fs";
+import { promises as fs28 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -11361,13 +11858,13 @@ function debouncedSave(sessionFile, history, memory) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path29.join(os17.homedir(), p.slice(1));
+    return path30.join(os17.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path29.join(os17.homedir(), ".bluma");
-  return path29.resolve(expandHome(fixed));
+  const fixed = path30.join(os17.homedir(), ".bluma");
+  return path30.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -11375,10 +11872,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path29.dirname(dest);
-      await fs27.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path30.dirname(dest);
+      await fs28.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs27.rename(src, dest);
+      await fs28.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -11391,13 +11888,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs27.access(src);
-    const data = await fs27.readFile(src);
-    const dir = path29.dirname(dest);
-    await fs27.mkdir(dir, { recursive: true }).catch(() => {
+    await fs28.access(src);
+    const data = await fs28.readFile(src);
+    const dir = path30.dirname(dest);
+    await fs28.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs27.writeFile(dest, data);
-    await fs27.unlink(src).catch(() => {
+    await fs28.writeFile(dest, data);
+    await fs28.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -11410,16 +11907,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path29.join(appDir, "sessions");
-  await fs27.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path30.join(appDir, "sessions");
+  await fs28.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadOrcreateSession(sessionId) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path29.join(sessionDir, `${sessionId}.json`);
+  const sessionFile = path30.join(sessionDir, `${sessionId}.json`);
   try {
-    await fs27.access(sessionFile);
-    const fileContent = await fs27.readFile(sessionFile, "utf-8");
+    await fs28.access(sessionFile);
+    const fileContent = await fs28.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     const memory = {
       historyAnchor: sessionData.history_anchor ?? null,
@@ -11432,7 +11929,7 @@ async function loadOrcreateSession(sessionId) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
-    await fs27.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    await fs28.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     const emptyMemory = {
       historyAnchor: null,
       compressedTurnSliceCount: 0
@@ -11444,12 +11941,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path29.dirname(sessionFile);
-      await fs27.mkdir(dir, { recursive: true });
+      const dir = path30.dirname(sessionFile);
+      await fs28.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs27.readFile(sessionFile, "utf-8");
+      const fileContent = await fs28.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -11460,14 +11957,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path29.basename(sessionFile, ".json");
+      const sessionId = path30.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs27.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs28.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -11483,7 +11980,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     }
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs27.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs28.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -11492,7 +11989,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs27.unlink(tempSessionFile);
+        await fs28.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -11510,13 +12007,13 @@ async function saveSessionHistory(sessionFile, history, memory) {
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os22 from "os";
-import fs34 from "fs";
-import path36 from "path";
+import fs35 from "fs";
+import path37 from "path";
 import { execSync as execSync4 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs28 from "fs";
-import path30 from "path";
+import fs29 from "fs";
+import path31 from "path";
 import os18 from "os";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var SkillLoader = class _SkillLoader {
@@ -11526,8 +12023,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path30.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path30.join(os18.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path31.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path31.join(os18.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -11536,48 +12033,48 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path30.join(process.cwd(), "dist", "config", "skills");
+      return path31.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path30.resolve(p);
+      const abs = path31.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path30.dirname(fileURLToPath4(import.meta.url));
-      push(path30.join(bundleDir, "config", "skills"));
+      const bundleDir = path31.dirname(fileURLToPath4(import.meta.url));
+      push(path31.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path30.isAbsolute(argv1) && fs28.existsSync(argv1)) {
-          resolved = fs28.realpathSync(argv1);
-        } else if (!path30.isAbsolute(argv1)) {
-          resolved = path30.resolve(process.cwd(), argv1);
+        if (path31.isAbsolute(argv1) && fs29.existsSync(argv1)) {
+          resolved = fs29.realpathSync(argv1);
+        } else if (!path31.isAbsolute(argv1)) {
+          resolved = path31.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path30.dirname(resolved);
-        argvBundled = path30.join(scriptDir, "config", "skills");
+        const scriptDir = path31.dirname(resolved);
+        argvBundled = path31.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
     }
     for (const abs of candidates) {
-      if (fs28.existsSync(abs)) {
+      if (fs29.existsSync(abs)) {
         return abs;
       }
     }
     try {
-      return path30.join(path30.dirname(fileURLToPath4(import.meta.url)), "config", "skills");
+      return path31.join(path31.dirname(fileURLToPath4(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path30.join(os18.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path31.join(os18.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -11606,8 +12103,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path30.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path30.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path31.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path31.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -11615,20 +12112,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs28.existsSync(dir)) return [];
+    if (!fs29.existsSync(dir)) return [];
     try {
-      return fs28.readdirSync(dir).filter((d) => {
-        const fullPath = path30.join(dir, d);
-        return fs28.statSync(fullPath).isDirectory() && fs28.existsSync(path30.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path30.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs29.readdirSync(dir).filter((d) => {
+        const fullPath = path31.join(dir, d);
+        return fs29.statSync(fullPath).isDirectory() && fs29.existsSync(path31.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path31.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs28.existsSync(skillPath)) return null;
+    if (!fs29.existsSync(skillPath)) return null;
     try {
-      const raw = fs28.readFileSync(skillPath, "utf-8");
+      const raw = fs29.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -11650,12 +12147,12 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path30.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path30.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path30.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs28.existsSync(bundledPath);
-    const existsProject = fs28.existsSync(projectPath);
-    const existsGlobal = fs28.existsSync(globalPath);
+    const bundledPath = path31.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path31.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path31.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs29.existsSync(bundledPath);
+    const existsProject = fs29.existsSync(projectPath);
+    const existsGlobal = fs29.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -11694,9 +12191,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs28.readFileSync(skillPath, "utf-8");
+      const raw = fs29.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path30.dirname(skillPath);
+      const skillDir = path31.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -11705,22 +12202,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path30.join(skillDir, "references")),
-        scripts: this.scanAssets(path30.join(skillDir, "scripts"))
+        references: this.scanAssets(path31.join(skillDir, "references")),
+        scripts: this.scanAssets(path31.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs28.existsSync(dir)) return [];
+    if (!fs29.existsSync(dir)) return [];
     try {
-      return fs28.readdirSync(dir).filter((f) => {
-        const fp = path30.join(dir, f);
-        return fs28.statSync(fp).isFile();
+      return fs29.readdirSync(dir).filter((f) => {
+        const fp = path31.join(dir, f);
+        return fs29.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path30.resolve(dir, f)
+        path: path31.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -11777,10 +12274,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path30.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path30.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path30.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs28.existsSync(bundledPath) || fs28.existsSync(projectPath) || fs28.existsSync(globalPath);
+    const bundledPath = path31.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path31.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path31.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs29.existsSync(bundledPath) || fs29.existsSync(projectPath) || fs29.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -11812,13 +12309,13 @@ var SkillLoader = class _SkillLoader {
 };
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
-import fs30 from "fs";
-import path32 from "path";
+import fs31 from "fs";
+import path33 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/utils/blumamd.ts
-import fs29 from "fs";
-import path31 from "path";
+import fs30 from "fs";
+import path32 from "path";
 import os19 from "os";
 import { execSync as execSync2 } 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.";
@@ -11948,12 +12445,12 @@ var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 function expandIncludePath(includePath, baseDir) {
   const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
   if (cleanPath.startsWith("~")) {
-    return path31.join(os19.homedir(), cleanPath.slice(1));
+    return path32.join(os19.homedir(), cleanPath.slice(1));
   }
-  if (path31.isAbsolute(cleanPath)) {
+  if (path32.isAbsolute(cleanPath)) {
     return cleanPath;
   }
-  return path31.resolve(baseDir, cleanPath);
+  return path32.resolve(baseDir, cleanPath);
 }
 function processIncludes(content, baseDir, processedFiles) {
   const lines = content.split("\n");
@@ -11962,20 +12459,20 @@ function processIncludes(content, baseDir, processedFiles) {
     const includeMatch = line.match(/^@\s*([^\s]+)/);
     if (includeMatch) {
       const includePath = expandIncludePath(includeMatch[1], baseDir);
-      const normalizedPath = path31.normalize(includePath);
+      const normalizedPath = path32.normalize(includePath);
       if (processedFiles.has(normalizedPath)) {
         result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
         continue;
       }
-      const ext = path31.extname(includePath).toLowerCase();
+      const ext = path32.extname(includePath).toLowerCase();
       if (!TEXT_FILE_EXTENSIONS.has(ext)) {
         result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
         continue;
       }
       try {
-        const includedContent = fs29.readFileSync(includePath, "utf-8");
+        const includedContent = fs30.readFileSync(includePath, "utf-8");
         processedFiles.add(normalizedPath);
-        const processedContent = processIncludes(includedContent, path31.dirname(includePath), processedFiles);
+        const processedContent = processIncludes(includedContent, path32.dirname(includePath), processedFiles);
         result.push(`
 <!-- BEGIN INCLUDE ${includeMatch[1]} -->
 `);
@@ -12021,9 +12518,9 @@ function parseFrontmatterPaths(paths) {
 }
 function readMemoryFile(filePath, type, includeBasePath) {
   try {
-    const rawContent = fs29.readFileSync(filePath, "utf-8");
-    const baseDir = includeBasePath || path31.dirname(filePath);
-    const processedFiles = /* @__PURE__ */ new Set([path31.normalize(filePath)]);
+    const rawContent = fs30.readFileSync(filePath, "utf-8");
+    const baseDir = includeBasePath || path32.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path32.normalize(filePath)]);
     const { frontmatter, content: withoutFrontmatter } = parseFrontmatter(rawContent);
     const globs = parseFrontmatterPaths(frontmatter.paths);
     const processedContent = processIncludes(withoutFrontmatter, baseDir, processedFiles);
@@ -12045,15 +12542,15 @@ function readMemoryFile(filePath, type, includeBasePath) {
 }
 function findGitRoot(startDir) {
   let current = startDir;
-  while (current !== path31.dirname(current)) {
-    const gitPath = path31.join(current, ".git");
+  while (current !== path32.dirname(current)) {
+    const gitPath = path32.join(current, ".git");
     try {
-      if (fs29.existsSync(gitPath)) {
+      if (fs30.existsSync(gitPath)) {
         return current;
       }
     } catch {
     }
-    current = path31.dirname(current);
+    current = path32.dirname(current);
   }
   return null;
 }
@@ -12078,17 +12575,17 @@ function getGitUserInfo(cwd) {
 }
 function processRulesDirectory(rulesDir, type, processedPaths, conditionalRule = false) {
   const result = [];
-  if (!fs29.existsSync(rulesDir)) {
+  if (!fs30.existsSync(rulesDir)) {
     return result;
   }
   try {
-    const entries = fs29.readdirSync(rulesDir, { withFileTypes: true });
+    const entries = fs30.readdirSync(rulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path31.join(rulesDir, entry.name);
+      const entryPath = path32.join(rulesDir, entry.name);
       if (entry.isDirectory()) {
         result.push(...processRulesDirectory(entryPath, type, processedPaths, conditionalRule));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const normalizedPath = path31.normalize(entryPath);
+        const normalizedPath = path32.normalize(entryPath);
         if (processedPaths.has(normalizedPath)) {
           continue;
         }
@@ -12124,13 +12621,13 @@ function loadManagedMemory() {
 function loadUserMemory() {
   const files = [];
   const homeDir = os19.homedir();
-  const userBlumaDir = path31.join(homeDir, ".bluma");
-  const userBlumaMd = path31.join(userBlumaDir, "BLUMA.md");
+  const userBlumaDir = path32.join(homeDir, ".bluma");
+  const userBlumaMd = path32.join(userBlumaDir, "BLUMA.md");
   const userFile = readMemoryFile(userBlumaMd, "User");
   if (userFile && userFile.content.trim()) {
     files.push(userFile);
   }
-  const userRulesDir = path31.join(userBlumaDir, "rules");
+  const userRulesDir = path32.join(userBlumaDir, "rules");
   const processedPaths = /* @__PURE__ */ new Set();
   files.push(...processRulesDirectory(userRulesDir, "User", processedPaths, false));
   return files;
@@ -12142,10 +12639,10 @@ function loadProjectMemory(cwd) {
   let currentDir = cwd;
   const MAX_TRAVERSAL_DEPTH = 20;
   let depth = 0;
-  const normalizedGitRoot = path31.resolve(gitRoot);
-  while (currentDir !== path31.dirname(currentDir) && path31.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
+  const normalizedGitRoot = path32.resolve(gitRoot);
+  while (currentDir !== path32.dirname(currentDir) && path32.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
     dirs.push(currentDir);
-    currentDir = path31.dirname(currentDir);
+    currentDir = path32.dirname(currentDir);
     depth++;
   }
   if (!dirs.includes(gitRoot)) {
@@ -12153,7 +12650,7 @@ function loadProjectMemory(cwd) {
   }
   const processedPaths = /* @__PURE__ */ new Set();
   for (const dir of dirs.reverse()) {
-    const projectBlumaMd = path31.join(dir, "BLUMA.md");
+    const projectBlumaMd = path32.join(dir, "BLUMA.md");
     if (!processedPaths.has(projectBlumaMd)) {
       processedPaths.add(projectBlumaMd);
       const projectFile = readMemoryFile(projectBlumaMd, "Project");
@@ -12161,7 +12658,7 @@ function loadProjectMemory(cwd) {
         files.push(projectFile);
       }
     }
-    const blumaDirBlumaMd = path31.join(dir, ".bluma", "BLUMA.md");
+    const blumaDirBlumaMd = path32.join(dir, ".bluma", "BLUMA.md");
     if (!processedPaths.has(blumaDirBlumaMd)) {
       processedPaths.add(blumaDirBlumaMd);
       const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "Project");
@@ -12169,10 +12666,10 @@ function loadProjectMemory(cwd) {
         files.push(blumaDirFile);
       }
     }
-    const rulesDir = path31.join(dir, ".bluma", "rules");
+    const rulesDir = path32.join(dir, ".bluma", "rules");
     files.push(...processRulesDirectory(rulesDir, "Project", processedPaths, false));
   }
-  const localBlumaMd = path31.join(cwd, "BLUMA.local.md");
+  const localBlumaMd = path32.join(cwd, "BLUMA.local.md");
   if (!processedPaths.has(localBlumaMd)) {
     processedPaths.add(localBlumaMd);
     const localFile = readMemoryFile(localBlumaMd, "Local");
@@ -12258,10 +12755,10 @@ var LIMITS = {
 };
 function safeReadFile(filePath, maxChars) {
   try {
-    if (!fs30.existsSync(filePath)) return null;
-    const st = fs30.statSync(filePath);
+    if (!fs31.existsSync(filePath)) return null;
+    const st = fs31.statSync(filePath);
     if (!st.isFile()) return null;
-    const raw = fs30.readFileSync(filePath, "utf8");
+    const raw = fs31.readFileSync(filePath, "utf8");
     if (raw.includes("\0")) return null;
     if (raw.length <= maxChars) return raw;
     return `${raw.slice(0, maxChars)}
@@ -12273,7 +12770,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path32.join(cwd, name), LIMITS.readme);
+    const c = safeReadFile(path33.join(cwd, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -12281,14 +12778,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd) {
   const paths = [
-    path32.join(cwd, "BluMa.md"),
-    path32.join(cwd, "BLUMA.md"),
-    path32.join(cwd, ".bluma", "BluMa.md")
+    path33.join(cwd, "BluMa.md"),
+    path33.join(cwd, "BLUMA.md"),
+    path33.join(cwd, ".bluma", "BluMa.md")
   ];
   for (const p of paths) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path32.relative(cwd, p) || p;
+      const rel = path33.relative(cwd, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -12296,10 +12793,10 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd) {
-  const p = path32.join(cwd, "package.json");
+  const p = path33.join(cwd, "package.json");
   try {
-    if (!fs30.existsSync(p)) return null;
-    const pkg = JSON.parse(fs30.readFileSync(p, "utf8"));
+    if (!fs31.existsSync(p)) return null;
+    const pkg = JSON.parse(fs31.readFileSync(p, "utf8"));
     const scripts = pkg.scripts;
     let scriptKeys = "";
     if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
@@ -12332,7 +12829,7 @@ function summarizePackageJson(cwd) {
 }
 function topLevelListing(cwd) {
   try {
-    const names = fs30.readdirSync(cwd, { withFileTypes: true });
+    const names = fs31.readdirSync(cwd, { withFileTypes: true });
     const sorted = [...names].sort((a, b) => a.name.localeCompare(b.name));
     const limited = sorted.slice(0, LIMITS.topDirEntries);
     const lines = limited.map((d) => `${d.name}${d.isDirectory() ? "/" : ""}`);
@@ -12390,7 +12887,7 @@ function buildWorkspaceSnapshot(cwd) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path32.join(cwd, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path33.join(cwd, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -12408,15 +12905,15 @@ function buildWorkspaceSnapshot(cwd) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path32.join(cwd, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path33.join(cwd, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path32.join(cwd, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path33.join(cwd, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path32.join(cwd, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path33.join(cwd, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -12452,14 +12949,14 @@ function buildWorkspaceSnapshot(cwd) {
   } else {
     parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
   }
-  const tsconfig = safeReadFile(path32.join(cwd, "tsconfig.json"), LIMITS.tsconfig);
+  const tsconfig = safeReadFile(path33.join(cwd, "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(path32.join(cwd, name), LIMITS.dockerfile);
+    const df = safeReadFile(path33.join(cwd, name), LIMITS.dockerfile);
     if (df) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -12469,7 +12966,7 @@ function buildWorkspaceSnapshot(cwd) {
     }
   }
   for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const dc = safeReadFile(path32.join(cwd, name), LIMITS.dockerfile);
+    const dc = safeReadFile(path33.join(cwd, name), LIMITS.dockerfile);
     if (dc) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -12484,12 +12981,12 @@ function buildWorkspaceSnapshot(cwd) {
     ".circleci/config.yml",
     "Jenkinsfile"
   ]) {
-    const ciFile = path32.join(cwd, ciPath);
-    if (fs30.existsSync(ciFile)) {
-      const st = fs30.statSync(ciFile);
+    const ciFile = path33.join(cwd, ciPath);
+    if (fs31.existsSync(ciFile)) {
+      const st = fs31.statSync(ciFile);
       if (st.isDirectory()) {
         try {
-          const wfFiles = fs30.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+          const wfFiles = fs31.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
           if (wfFiles.length > 0) {
             parts.push(`### GitHub Actions workflows
 \`${wfFiles.join("`, `")}\`
@@ -12500,7 +12997,7 @@ function buildWorkspaceSnapshot(cwd) {
       } else {
         const ci = safeReadFile(ciFile, LIMITS.ciConfig);
         if (ci) {
-          parts.push(`### CI config (${path32.basename(ciPath)})
+          parts.push(`### CI config (${path33.basename(ciPath)})
 `);
           parts.push(ci);
           parts.push("\n");
@@ -12509,8 +13006,8 @@ function buildWorkspaceSnapshot(cwd) {
     }
   }
   for (const depFile of ["requirements.txt", "Pipfile", "poetry.lock", "Gemfile", "go.sum", "Cargo.lock"]) {
-    const depPath = path32.join(cwd, depFile);
-    if (fs30.existsSync(depPath)) {
+    const depPath = path33.join(cwd, depFile);
+    if (fs31.existsSync(depPath)) {
       const depContent = safeReadFile(depPath, 1500);
       if (depContent) {
         parts.push(`### ${depFile} (top entries)
@@ -12523,10 +13020,10 @@ function buildWorkspaceSnapshot(cwd) {
     }
   }
   for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
-    const envPath = path32.join(cwd, envFile);
-    if (fs30.existsSync(envPath)) {
+    const envPath = path33.join(cwd, envFile);
+    if (fs31.existsSync(envPath)) {
       try {
-        const raw = fs30.readFileSync(envPath, "utf-8");
+        const raw = fs31.readFileSync(envPath, "utf-8");
         const keys = raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => {
           const eqIndex = l.indexOf("=");
           return eqIndex >= 0 ? l.slice(0, eqIndex).trim() : l.trim();
@@ -12549,15 +13046,15 @@ init_runtime_config();
 
 // src/app/agent/runtime/plugin_registry.ts
 init_sandbox_policy();
-import fs31 from "fs";
+import fs32 from "fs";
 import os20 from "os";
-import path33 from "path";
+import path34 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path33.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path34.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path33.join(process.env.HOME || os20.homedir(), ".bluma", "plugins");
+  return path34.join(process.env.HOME || os20.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -12566,11 +13063,11 @@ function getPluginDirs() {
   };
 }
 function readManifest(manifestPath, fallbackName) {
-  if (!fs31.existsSync(manifestPath)) {
+  if (!fs32.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs31.readFileSync(manifestPath, "utf-8"));
+    const parsed = JSON.parse(fs32.readFileSync(manifestPath, "utf-8"));
     return {
       name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : fallbackName,
       description: typeof parsed.description === "string" ? parsed.description.trim() : void 0,
@@ -12583,22 +13080,22 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path33.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path33.join(pluginDir, "plugin.json")
+    path34.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path34.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
-    if (fs31.existsSync(candidate)) {
+    if (fs32.existsSync(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 function listFromDir(baseDir, source) {
-  if (!fs31.existsSync(baseDir)) {
+  if (!fs32.existsSync(baseDir)) {
     return [];
   }
-  return fs31.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path33.join(baseDir, entry.name);
+  return fs32.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+    const pluginDir = path34.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -13041,13 +13538,23 @@ Since you are in an **isolated sandbox**, ALL tools are auto-approved:
 - \\\`notebook_edit\\\` - Jupyter notebook editing (auto-approved)
 - \\\`cron_create\\\` - Schedule reminders (auto-approved)
 
+### FactorAI Workspace Tools
+When a deployed app is attached to this sandbox, the following tools may appear and are sandbox-only:
+- \\\`factorai.sh.create_next_app\\\` - Create a new Next.js project in the sandbox
+- \\\`factorai.sh.deploy_app\\\` - Deploy a Next.js project from the sandbox to the hosting backend
+- \\\`factorai.sh.get_app_status\\\` - Read app status and contract context
+- \\\`factorai.sh.apply_app_changes\\\` - Apply incremental file changes to the app workspace
+- \\\`factorai.sh.redeploy_app\\\` - Redeploy the current app revision after edits
+
+Use \\\`factorai.sh.json\\\` as a normal workspace file. Do not treat manifest reading as a tool call.
+
 ---
 
 ## \u{1F680} NEXT.JS DEPLOY WORKFLOW - SEVERINO INTEGRATION
 
 You have access to **two specialized tools** for creating and deploying Next.js apps to Severino:
 
-### Tool 1: \\\`create_next_app\\\`
+### Tool 1: \\\`factorai.sh.create_next_app\\\`
 
 **Purpose:** Instant scaffold of a complete Next.js project with App Router, shadcn/ui, and Tailwind CSS.
 
@@ -13058,7 +13565,7 @@ You have access to **two specialized tools** for creating and deploying Next.js
 
 **Example:**
 \\\`\\\`\\\`typescript
-const result = await createNextApp({
+const result = await factorai.sh.create_next_app({
   name: 'erp-dashboard',
   template: 'full',
 });
@@ -13079,7 +13586,7 @@ const result = await createNextApp({
 
 ---
 
-### Tool 2: \\\`deploy_app\\\`
+### Tool 2: \\\`factorai.sh.deploy_app\\\`
 
 **Purpose:** Zip and deploy a Next.js project to Severino for hosting.
 
@@ -13091,7 +13598,7 @@ const result = await createNextApp({
 
 **Example:**
 \\\`\\\`\\\`typescript
-const result = await deployApp({
+const result = await factorai.sh.deploy_app({
   projectDir: './erp-dashboard',
   name: 'erp-dashboard',
 });
@@ -13112,10 +13619,17 @@ const result = await deployApp({
 - O ZIP deve conter **apenas c\xF3digo fonte e configs**
 - \\\`node_modules\\\` \xE9 recriado no servidor com \\\`npm install\\\`
 - Incluir \\\`node_modules\\\` = ZIP de 200MB+ = deploy falha
-- A tool \\\`deploy_app\\\` j\xE1 exclui automaticamente, mas se fizeres ZIP manual: **exclui \\\`node_modules\\\`**
+- A tool \\\`factorai.sh.deploy_app\\\` j\xE1 exclui automaticamente, mas se fizeres ZIP manual: **exclui \\\`node_modules\\\`**
 
 **Important:** The deploy is **asynchronous** - status starts as \\\`'building'\\\`. The app will be ready in ~30-60 seconds.
 
+**After this tool returns**
+- Read the returned metadata immediately.
+- Create or update \\\`factorai.sh.json\\\` in the project root.
+- Persist the deployment context there: \\\`appId\\\`, \\\`tenantId\\\`, \\\`projectId\\\`, \\\`workspaceId\\\`, \\\`revisionId\\\`, \\\`deploymentId\\\`, \\\`buildJobId\\\`, and \\\`appUrl\\\` when available.
+- Treat \\\`factorai.sh.json\\\` as the source of truth for future incremental edits and redeploys.
+- Do not invent a second manifest file or duplicate state elsewhere.
+
 ---
 
 ### Complete Workflow Example
@@ -13123,7 +13637,7 @@ const result = await deployApp({
 \\\`\\\`\\\`typescript
 // Step 1: Create project
 message({ message_type: 'info', content: 'Step 1/3: Creating Next.js project...' });
-const scaffold = await createNextApp({
+const scaffold = await factorai.sh.create_next_app({
   name: 'erp-dashboard',
   template: 'full',
 });
@@ -13137,7 +13651,7 @@ await fileWrite({
 
 // Step 3: Deploy
 message({ message_type: 'info', content: 'Step 3/3: Deploying to Severino...' });
-const deploy = await deployApp({
+const deploy = await factorai.sh.deploy_app({
   projectDir: './erp-dashboard',
   name: 'erp-dashboard',
 });
@@ -13155,7 +13669,7 @@ message({
 ### \u26A0\uFE0F Critical Requirements for Deploy
 
 1. **\\\`output: 'standalone'\\\` in \\\`next.config.js\\\`**
-   - The \\\`create_next_app\\\` tool already includes this
+   - The \\\`factorai.sh.create_next_app\\\` tool already includes this
    - If you modify \\\`next.config.js\\\`, keep this setting
 
 2. **Build before deploy (optional but recommended)**
@@ -13493,8 +14007,8 @@ function buildModelInfoSection(modelId) {
 
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
-import fs32 from "fs";
-import path34 from "path";
+import fs33 from "fs";
+import path35 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -13505,7 +14019,7 @@ var cache2 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path34.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path35.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -13524,8 +14038,8 @@ function ensureLoaded2() {
     return cache2;
   }
   try {
-    if (fs32.existsSync(statePath)) {
-      const parsed = JSON.parse(fs32.readFileSync(statePath, "utf-8"));
+    if (fs33.existsSync(statePath)) {
+      const parsed = JSON.parse(fs33.readFileSync(statePath, "utf-8"));
       cache2 = {
         enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_STATE.enabled,
         maxEvents: typeof parsed.maxEvents === "number" && Number.isFinite(parsed.maxEvents) && parsed.maxEvents > 0 ? Math.floor(parsed.maxEvents) : DEFAULT_STATE.maxEvents,
@@ -13551,9 +14065,9 @@ function ensureLoaded2() {
 }
 function persist2(state) {
   const statePath = getStatePath();
-  fs32.mkdirSync(path34.dirname(statePath), { recursive: true });
+  fs33.mkdirSync(path35.dirname(statePath), { recursive: true });
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs32.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+  fs33.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
   cache2 = state;
   cachePath2 = statePath;
 }
@@ -13622,18 +14136,18 @@ function buildSystemRemindersSection() {
 }
 
 // src/app/agent/core/prompt/auto_memory.ts
-import fs33 from "fs";
-import path35 from "path";
+import fs34 from "fs";
+import path36 from "path";
 import os21 from "os";
-var AUTO_MEMORY_FILE = path35.join(os21.homedir(), ".bluma", "auto_memory.md");
+var AUTO_MEMORY_FILE = path36.join(os21.homedir(), ".bluma", "auto_memory.md");
 var MAX_AUTO_MEMORY_CHARS = 25e3;
 var MAX_AUTO_MEMORY_LINES = 200;
 function getAutoMemoryForPrompt() {
   try {
-    if (!fs33.existsSync(AUTO_MEMORY_FILE)) {
+    if (!fs34.existsSync(AUTO_MEMORY_FILE)) {
       return "";
     }
-    let content = fs33.readFileSync(AUTO_MEMORY_FILE, "utf-8");
+    let content = fs34.readFileSync(AUTO_MEMORY_FILE, "utf-8");
     if (!content.trim()) {
       return "";
     }
@@ -13692,10 +14206,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs34.existsSync(path36.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs34.existsSync(path36.join(dir, "yarn.lock"))) return "yarn";
-    if (fs34.existsSync(path36.join(dir, "bun.lockb"))) return "bun";
-    if (fs34.existsSync(path36.join(dir, "package-lock.json"))) return "npm";
+    if (fs35.existsSync(path37.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs35.existsSync(path37.join(dir, "yarn.lock"))) return "yarn";
+    if (fs35.existsSync(path37.join(dir, "bun.lockb"))) return "bun";
+    if (fs35.existsSync(path37.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -13703,9 +14217,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs34.readdirSync(dir);
+    const files = fs35.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs34.readFileSync(path36.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs35.readFileSync(path37.join(dir, "package.json"), "utf-8"));
       if (pkg.dependencies?.next || pkg.devDependencies?.next) return "Next.js";
       if (pkg.dependencies?.react || pkg.devDependencies?.react) return "React";
       if (pkg.dependencies?.express || pkg.devDependencies?.express) return "Express";
@@ -13724,9 +14238,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path36.join(dir, "package.json");
-    if (fs34.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path37.join(dir, "package.json");
+    if (fs35.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -13735,7 +14249,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs34.existsSync(path36.join(dir, "pytest.ini")) || fs34.existsSync(path36.join(dir, "conftest.py"))) return "pytest";
+    if (fs35.existsSync(path37.join(dir, "pytest.ini")) || fs35.existsSync(path37.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -13743,9 +14257,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path36.join(dir, "package.json");
-    if (fs34.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path37.join(dir, "package.json");
+    if (fs35.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -13937,7 +14451,15 @@ async function getUnifiedSystemPrompt(availableSkills, options) {
     const fromAgent = process.env.BLUMA_FROM_AGENT || "severino";
     const action = process.env.BLUMA_ACTION || "unknown";
     const sessionId = process.env.BLUMA_SESSION_ID || "unknown";
+    const factorAiAppContext = loadFactorAiAppContext();
     prompt = prompt.replaceAll("{from_agent}", fromAgent).replaceAll("{action}", action).replaceAll("{session_id}", sessionId).replaceAll("{workspace_root}", env.workdir);
+    if (factorAiAppContext) {
+      prompt += `
+
+<factorai_app_context>
+${formatFactorAiAppContextSummary(factorAiAppContext)}
+</factorai_app_context>`;
+    }
   }
   prompt += buildOutputStylePrompt(runtimeConfig.outputStyle);
   prompt += buildPermissionModePrompt(runtimeConfig.permissionMode);
@@ -14037,8 +14559,8 @@ ${blumaMdContent}
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path36.join(dir, ".git");
-    return fs34.existsSync(gitPath) && fs34.lstatSync(gitPath).isDirectory();
+    const gitPath = path37.join(dir, ".git");
+    return fs35.existsSync(gitPath) && fs35.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -14246,7 +14768,8 @@ function defaultBlumaUserContextInput(sessionId, userMessage) {
     userName: null,
     userEmail: null,
     companyId: null,
-    companyName: null
+    companyName: null,
+    appContext: loadFactorAiAppContext()
   };
 }
 function getPreferredMacAddress() {
@@ -14784,11 +15307,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/natives/coding_memory_consolidate.ts
-import * as fs35 from "fs";
-import * as path37 from "path";
+import * as fs36 from "fs";
+import * as path38 from "path";
 import os24 from "os";
 function memoryPath2() {
-  return path37.join(process.env.HOME || os24.homedir(), ".bluma", "coding_memory.json");
+  return path38.join(process.env.HOME || os24.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -14798,18 +15321,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath2();
-  if (!fs35.existsSync(p)) {
+  if (!fs36.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs35.copyFileSync(p, bak);
+    fs36.copyFileSync(p, bak);
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `backup failed: ${e.message}` };
   }
   let data;
   try {
-    data = JSON.parse(fs35.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs36.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -14844,7 +15367,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs35.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs36.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -14887,7 +15410,8 @@ function buildTurnStartBackendMessage(params) {
     type: "turn_start",
     turnId: params.turnId,
     sessionId: params.sessionId,
-    userPromptPreview: buildUserPromptPreview(params.inputText)
+    userPromptPreview: buildUserPromptPreview(params.inputText),
+    appContext: params.appContext ?? null
   };
 }
 
@@ -15069,7 +15593,8 @@ var BluMaAgent = class {
       buildTurnStartBackendMessage({
         turnId: this.activeTurnContext.turnId,
         sessionId: this.activeTurnContext.sessionId,
-        inputText
+        inputText,
+        appContext: this.activeTurnContext.appContext ?? null
       })
     );
     if (inputText === "/init") {
@@ -15449,7 +15974,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path38.basename(toolArgs.file_path);
+      const filename = path39.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}`;
@@ -16425,16 +16950,16 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 }
 
 // src/app/agent/core/memory/session_memory.ts
-import fs36 from "fs";
+import fs37 from "fs";
 import os27 from "os";
-import path39 from "path";
+import path40 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path39.join(os27.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path40.join(os27.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -16491,15 +17016,15 @@ ${messages.slice(-50).map((m) => `${m.role}: ${m.content.slice(0, 500)}`).join("
     );
     unique.sort((a, b) => b.accessCount - a.accessCount);
     const trimmed = unique.slice(0, 200);
-    fs36.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
+    fs37.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
   }
   /**
    * Load memories from disk
    */
   async loadMemories() {
     try {
-      if (!fs36.existsSync(this.memoryFile)) return [];
-      const data = fs36.readFileSync(this.memoryFile, "utf-8");
+      if (!fs37.existsSync(this.memoryFile)) return [];
+      const data = fs37.readFileSync(this.memoryFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return [];
@@ -17036,14 +17561,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path44, handler) {
-    this.routeHandlers.set(path44, handler);
+  registerRoute(path45, handler) {
+    this.routeHandlers.set(path45, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext } = payload;
-    for (const [path44, handler] of this.routeHandlers) {
-      if (inputText === path44 || inputText.startsWith(`${path44} `)) {
+    for (const [path45, handler] of this.routeHandlers) {
+      if (inputText === path45 || inputText.startsWith(`${path45} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -17052,13 +17577,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path40 from "path";
+import path41 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 = path40.resolve(p.root, entry);
+    const abs = path41.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -17079,7 +17604,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path41.join(os28.homedir(), ".bluma", ".env");
+var globalEnvPath = path42.join(os28.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -17091,9 +17616,11 @@ var Agent = class {
   core;
   subAgents;
   toolInvoker;
+  factorAiAppContext;
   constructor(sessionId, eventBus) {
     this.sessionId = sessionId;
     this.eventBus = eventBus;
+    this.factorAiAppContext = loadFactorAiAppContext();
     const nativeToolInvoker = new ToolInvoker();
     this.toolInvoker = nativeToolInvoker;
     this.mcpClient = new MCPClient(nativeToolInvoker, eventBus);
@@ -17209,6 +17736,9 @@ var Agent = class {
   async processTurn(userInput, userContextInput) {
     const inputText = String(userInput.content || "").trim();
     const resolvedUserContext = userContextInput ?? defaultInteractiveCliUserContextInput(this.sessionId, inputText.slice(0, 300));
+    if (this.factorAiAppContext && !resolvedUserContext.appContext) {
+      resolvedUserContext.appContext = this.factorAiAppContext;
+    }
     if (inputText === "/init" || inputText.startsWith("/init ")) {
       this.routeManager.registerRoute("/init", this.dispatchToSubAgent);
     }
@@ -21660,16 +22190,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import path42 from "path";
-import fs37 from "fs";
+import path43 from "path";
+import fs38 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 = path42.join(dir, "package.json");
-    if (fs37.existsSync(candidate)) {
+    const candidate = path43.join(dir, "package.json");
+    if (fs38.existsSync(candidate)) {
       try {
-        const raw = fs37.readFileSync(candidate, "utf8");
+        const raw = fs38.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -21677,7 +22207,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path42.dirname(dir);
+    const parent = path43.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -21686,13 +22216,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path42.resolve(dir);
+    const abs = path43.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path42.dirname(fileURLToPath5(import.meta.url)));
+    const fromBundle = tryFrom(path43.dirname(fileURLToPath5(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -21700,12 +22230,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path42.isAbsolute(argv1) && fs37.existsSync(argv1)) {
-        resolved = fs37.realpathSync(argv1);
+      if (path43.isAbsolute(argv1) && fs38.existsSync(argv1)) {
+        resolved = fs38.realpathSync(argv1);
       } else {
-        resolved = path42.resolve(process.cwd(), argv1);
+        resolved = path43.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path42.dirname(resolved));
+      const fromArgv = tryFrom(path43.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -23442,9 +23972,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs38.readFileSync(filePath, "utf-8");
+      rawPayload = fs39.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs38.readFileSync(0, "utf-8");
+      rawPayload = fs39.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -23642,9 +24172,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path43.dirname(fileURLToPath6(import.meta.url));
-    const pkgPath = path43.join(base, "..", "package.json");
-    const j = JSON.parse(fs38.readFileSync(pkgPath, "utf8"));
+    const base = path44.dirname(fileURLToPath6(import.meta.url));
+    const pkgPath = path44.join(base, "..", "package.json");
+    const j = JSON.parse(fs39.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -23767,7 +24297,7 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs38.readFileSync(filePath, "utf-8");
+  const rawPayload = fs39.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
   const sessionId = envelope.session_id || envelope.message_id || uuidv412();
   registerSession({