npm - @nomad-e/bluma-cli - Versions diffs - 0.1.71 → 0.1.73 - Mend

@nomad-e/bluma-cli 0.1.71 → 0.1.73

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

Files changed (5) hide show

package/README.md +3 -0
package/dist/config/skills/git-commit/SKILL.md +49 -7
package/dist/config/skills/git-commit/references/REFERENCE.md +5 -1
package/dist/main.js +805 -257
package/package.json +1 -1

package/dist/main.js CHANGED Viewed

@@ -199,7 +199,7 @@ var init_permission_rules = __esm({
       matchesPattern(pattern, value) {
         if (pattern === "*") return true;
         if (pattern.includes("*")) {
-          const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+          const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, ".*");
           const regex = new RegExp("^" + escaped + "$");
           return regex.test(value);
         }
@@ -319,13 +319,31 @@ var init_sandbox_policy = __esm({
     init_runtime_config();
     init_permission_rules();
     BLOCKED_COMMAND_PATTERNS = [
-      // No command patterns blocked — sandbox isolation handles safety
+      { pattern: /\bsudo\b/, reason: "Privilege escalation is not allowed." },
+      { pattern: /\bsu\b\s/, reason: "User switching is not allowed." },
+      { pattern: /\brm\s+-rf\s+\/\b/, reason: "Deleting root filesystem is blocked." },
+      { pattern: /\bcurl\b.*\|\s*(bash|sh|zsh)/i, reason: "Pipe-to-shell execution is blocked." },
+      { pattern: /\bwget\b.*\|\s*(bash|sh|zsh)/i, reason: "Pipe-to-shell execution is blocked." },
+      { pattern: /\beval\b\s*\(/, reason: "Eval execution is blocked." },
+      { pattern: /\bmkfs\b/, reason: "Filesystem formatting is blocked." },
+      { pattern: /\bdd\s+of=/, reason: "Raw disk write is blocked." }
     ];
     HIGH_RISK_COMMAND_PATTERNS = [
-      // No high-risk patterns — all commands allowed inside sandbox
+      /\brm\s+-rf\b/,
+      /\bchmod\s+-?777\b/,
+      /\bchown\s/,
+      /\bmkfs\b/,
+      /\bformat\b/
     ];
     MODERATE_RISK_COMMAND_PATTERNS = [
-      // No moderate-risk patterns — all commands allowed inside sandbox
+      /\bnpm\s+install\b/,
+      /\bnpm\s+update\b/,
+      /\byarn\s+install\b/,
+      /\byarn\s+upgrade\b/,
+      /\bpnpm\s+install\b/,
+      /\bpip\s+install\b/,
+      /\bapt-get\s+install\b/,
+      /\bbrew\s+install\b/
     ];
   }
 });
@@ -1737,8 +1755,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 +4456,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 +4790,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 +4799,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs8(Text8, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, children: [
       " ",
-      path44
+      path45
     ] })
   ] });
 };
@@ -5207,12 +5225,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 +10326,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 +10475,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 +10497,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 +11446,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 +11518,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 +11545,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 +11592,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 +11621,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 +11657,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 +11834,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 +11876,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 +11890,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 +11906,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 +11925,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 +11947,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 +11959,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 +11975,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 +11998,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 +12007,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 +12025,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 +12041,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 +12051,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 +12121,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 +12130,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 +12165,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 +12209,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 +12220,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 +12292,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 +12327,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 +12463,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 +12477,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 +12536,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 +12560,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 +12593,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 +12639,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 +12657,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 +12668,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 +12676,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 +12684,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 +12773,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 +12788,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 +12796,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 +12811,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 +12847,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 +12905,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 +12923,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 +12967,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 +12984,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 +12999,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 +13015,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 +13024,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 +13038,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 +13064,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 +13081,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 +13098,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 +13556,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 +13583,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 +13604,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 +13616,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 +13637,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 +13655,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 +13669,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 +13687,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 +14025,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 +14037,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 +14056,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 +14083,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 +14154,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 +14224,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 +14235,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 +14256,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 +14267,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 +14275,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 +14469,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 +14577,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 +14786,8 @@ function defaultBlumaUserContextInput(sessionId, userMessage) {
     userName: null,
     userEmail: null,
     companyId: null,
-    companyName: null
+    companyName: null,
+    appContext: loadFactorAiAppContext()
   };
 }
 function getPreferredMacAddress() {
@@ -14784,11 +15325,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 +15339,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 +15385,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 +15428,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 +15611,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 +15992,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 +16968,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 +17034,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 +17579,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 +17595,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 +17622,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 +17634,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 +17754,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 +22208,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 +22225,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path42.dirname(dir);
+    const parent = path43.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -21686,13 +22234,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 +22248,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 +23990,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 +24190,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 +24315,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({