@nomad-e/bluma-cli 0.11.2 → 0.13.0

package/dist/main.js

@@ -2684,11 +2684,11 @@ var NodeFsOperations = {
       if (fd) fs.closeSync(fd);
     }
   },
-  appendFileSync(path57, data, options) {
-    const _ = slowLogging`fs.appendFileSync(${path57}, ${data.length} chars)`;
+  appendFileSync(path58, data, options) {
+    const _ = slowLogging`fs.appendFileSync(${path58}, ${data.length} chars)`;
     if (options?.mode !== void 0) {
       try {
-        const fd = fs.openSync(path57, "ax", options.mode);
+        const fd = fs.openSync(path58, "ax", options.mode);
         try {
           fs.appendFileSync(fd, data);
         } finally {
@@ -2699,35 +2699,35 @@ var NodeFsOperations = {
         if (getErrnoCode(e) !== "EEXIST") throw e;
       }
     }
-    fs.appendFileSync(path57, data);
+    fs.appendFileSync(path58, data);
   },
   copyFileSync(src, dest) {
     const _ = slowLogging`fs.copyFileSync(${src} → ${dest})`;
     fs.copyFileSync(src, dest);
   },
-  unlinkSync(path57) {
-    const _ = slowLogging`fs.unlinkSync(${path57})`;
-    fs.unlinkSync(path57);
+  unlinkSync(path58) {
+    const _ = slowLogging`fs.unlinkSync(${path58})`;
+    fs.unlinkSync(path58);
   },
   renameSync(oldPath, newPath) {
     const _ = slowLogging`fs.renameSync(${oldPath} → ${newPath})`;
     fs.renameSync(oldPath, newPath);
   },
-  linkSync(target, path57) {
-    const _ = slowLogging`fs.linkSync(${target} → ${path57})`;
-    fs.linkSync(target, path57);
+  linkSync(target, path58) {
+    const _ = slowLogging`fs.linkSync(${target} → ${path58})`;
+    fs.linkSync(target, path58);
   },
-  symlinkSync(target, path57, type) {
-    const _ = slowLogging`fs.symlinkSync(${target} → ${path57})`;
-    fs.symlinkSync(target, path57, type);
+  symlinkSync(target, path58, type) {
+    const _ = slowLogging`fs.symlinkSync(${target} → ${path58})`;
+    fs.symlinkSync(target, path58, type);
   },
-  readlinkSync(path57) {
-    const _ = slowLogging`fs.readlinkSync(${path57})`;
-    return fs.readlinkSync(path57);
+  readlinkSync(path58) {
+    const _ = slowLogging`fs.readlinkSync(${path58})`;
+    return fs.readlinkSync(path58);
   },
-  realpathSync(path57) {
-    const _ = slowLogging`fs.realpathSync(${path57})`;
-    return fs.realpathSync(path57).normalize("NFC");
+  realpathSync(path58) {
+    const _ = slowLogging`fs.realpathSync(${path58})`;
+    return fs.realpathSync(path58).normalize("NFC");
   },
   mkdirSync(dirPath, options) {
     const _ = slowLogging`fs.mkdirSync(${dirPath})`;
@@ -2760,12 +2760,12 @@ var NodeFsOperations = {
     const _ = slowLogging`fs.rmdirSync(${dirPath})`;
     fs.rmdirSync(dirPath);
   },
-  rmSync(path57, options) {
-    const _ = slowLogging`fs.rmSync(${path57})`;
-    fs.rmSync(path57, options);
+  rmSync(path58, options) {
+    const _ = slowLogging`fs.rmSync(${path58})`;
+    fs.rmSync(path58, options);
   },
-  createWriteStream(path57) {
-    return fs.createWriteStream(path57);
+  createWriteStream(path58) {
+    return fs.createWriteStream(path58);
   },
   async readFileBytes(fsPath, maxBytes) {
     if (maxBytes === void 0) {
@@ -2872,12 +2872,12 @@ function shouldLogDebugMessage(message2) {
 var hasFormattedOutput = false;
 var debugWriter = null;
 var pendingWrite = Promise.resolve();
-async function appendAsync(needMkdir, dir, path57, content) {
+async function appendAsync(needMkdir, dir, path58, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {
     });
   }
-  await appendFile(path57, content);
+  await appendFile(path58, content);
   void updateLatestDebugLogSymlink();
 }
 function noop() {
@@ -2887,8 +2887,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path57 = getDebugLogPath();
-        const dir = dirname(path57);
+        const path58 = getDebugLogPath();
+        const dir = dirname(path58);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -2898,11 +2898,11 @@ function getDebugWriter() {
             } catch {
             }
           }
-          getFsImplementation().appendFileSync(path57, content);
+          getFsImplementation().appendFileSync(path58, content);
           void updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path57, content)).catch(noop);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path58, content)).catch(noop);
       },
       flushIntervalMs: 1e3,
       maxBufferSize: 100,
@@ -9089,8 +9089,8 @@ import codeExcerpt from "code-excerpt";
 import { readFileSync as readFileSync2 } from "fs";
 import StackUtils from "stack-utils";
 import { jsx as jsx6, jsxs } from "react/jsx-runtime";
-var cleanupPath = (path57) => {
-  return path57?.replace(`file://${process.cwd()}/`, "");
+var cleanupPath = (path58) => {
+  return path58?.replace(`file://${process.cwd()}/`, "");
 };
 var stackUtils;
 function getStackUtils() {
@@ -13067,9 +13067,9 @@ var getInstance = (stdout, createInstance) => {
 
 // src/main.ts
 import { EventEmitter as EventEmitter7 } from "events";
-import fs50 from "fs";
-import path56 from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import fs51 from "fs";
+import path57 from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
 import chalk3 from "chalk";
@@ -13962,13 +13962,13 @@ function cancelSlashSubmenu() {
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path47 from "path";
+import path48 from "path";
 import os30 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs25 } from "fs";
-import path28 from "path";
-import { fileURLToPath } from "url";
+import { promises as fs26 } from "fs";
+import path29 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/app/agent/tools/EditTool/EditTool.ts
 init_sandbox_policy();
@@ -18664,8 +18664,9 @@ async function context_collapse(args = {}) {
 
 // src/app/agent/tools/CreateNextAppTool/CreateNextAppTool.ts
 init_sandbox_policy();
-import { promises as fs23 } from "fs";
-import path25 from "path";
+import { promises as fs24 } from "fs";
+import path26 from "path";
+import { fileURLToPath } from "url";
 
 // src/app/agent/tools/ShellCommandTool/ShellCommandTool.ts
 init_sandbox_policy();
@@ -18966,516 +18967,271 @@ function formatResult(result, verbose) {
   return JSON.stringify(output, null, 2);
 }
 
-// src/app/agent/tools/CreateNextAppTool/CreateNextAppTool.ts
-var MINIMAL_FILES = {
-  "package.json": `{
-  "name": "{{NAME}}",
-  "version": "0.1.0",
-  "private": true,
-  "scripts": {
-    "dev": "next dev",
-    "build": "next build",
-    "start": "next start",
-    "lint": "next lint"
-  },
-  "dependencies": {
-    "next": "^14.1.0",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.11.0",
-    "@types/react": "^18.2.0",
-    "@types/react-dom": "^18.2.0",
-    "typescript": "^5.3.0",
-    "tailwindcss": "^3.4.0",
-    "postcss": "^8.4.0",
-    "autoprefixer": "^10.4.0",
-    "eslint": "^8.56.0",
-    "eslint-config-next": "^14.1.0"
-  }
-}
-`,
-  "tsconfig.json": `{
-  "compilerOptions": {
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "preserve",
-    "incremental": true,
-    "plugins": [
-      {
-        "name": "next"
-      }
-    ],
-    "paths": {
-      "@/*": ["./*"]
+// src/app/agent/tools/CreateNextAppTool/scaffold_agent_guide.ts
+import { promises as fs23 } from "fs";
+import path25 from "path";
+var DESIGN_DOC_FILENAME = "DESIGN.md";
+var UI_GROUPS = {
+  "Actions & inputs": [
+    "button",
+    "input",
+    "textarea",
+    "checkbox",
+    "radio-group",
+    "switch",
+    "slider",
+    "select",
+    "input-otp",
+    "form",
+    "label"
+  ],
+  "Layout & navigation": [
+    "card",
+    "separator",
+    "tabs",
+    "accordion",
+    "collapsible",
+    "breadcrumb",
+    "navigation-menu",
+    "menubar",
+    "pagination",
+    "resizable",
+    "scroll-area",
+    "aspect-ratio"
+  ],
+  "Overlays & feedback": [
+    "dialog",
+    "alert-dialog",
+    "sheet",
+    "drawer",
+    "popover",
+    "hover-card",
+    "tooltip",
+    "alert",
+    "toast",
+    "toaster",
+    "sonner",
+    "progress",
+    "skeleton"
+  ],
+  "Data & media": [
+    "table",
+    "chart",
+    "calendar",
+    "carousel",
+    "avatar",
+    "badge",
+    "command",
+    "context-menu",
+    "dropdown-menu"
+  ]
+};
+async function listUiComponents(projectPath) {
+  const uiDir = path25.join(projectPath, "components", "ui");
+  try {
+    const entries = await fs23.readdir(uiDir);
+    return entries.filter((f) => f.endsWith(".jsx") || f.endsWith(".tsx")).map((f) => f.replace(/\.(jsx|tsx)$/, "")).sort();
+  } catch {
+    return [];
+  }
+}
+function hslTokenRows() {
+  return [
+    { name: "Canvas", varName: "--background", role: "Page background (`bg-background`)" },
+    { name: "Frost", varName: "--foreground", role: "Primary text (`text-foreground`)" },
+    { name: "Card", varName: "--card", role: "Elevated panels (`bg-card`, `text-card-foreground`)" },
+    { name: "Muted", varName: "--muted", role: "Secondary surfaces (`bg-muted`, `text-muted-foreground`)" },
+    { name: "Primary", varName: "--primary", role: "Primary actions (`bg-primary`, `text-primary-foreground`)" },
+    { name: "Accent", varName: "--accent", role: "Hover states (`bg-accent`, `text-accent-foreground`)" },
+    { name: "Border", varName: "--border", role: "Dividers and outlines (`border-border`)" },
+    { name: "Ring", varName: "--ring", role: "Focus rings (`ring-ring`)" },
+    { name: "Destructive", varName: "--destructive", role: "Errors and destructive actions" }
+  ];
+}
+function componentInventoryMarkdown(components) {
+  const lines = [];
+  for (const [group, names] of Object.entries(UI_GROUPS)) {
+    const present = names.filter((n) => components.includes(n));
+    if (present.length === 0) continue;
+    lines.push(`### ${group}`);
+    for (const n of present) {
+      lines.push(`- \`@/components/ui/${n}\` \u2014 \`${toPascal(n)}\``);
     }
-  },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules"]
+    lines.push("");
+  }
+  const uncategorized = components.filter(
+    (c) => !Object.values(UI_GROUPS).flat().includes(c)
+  );
+  if (uncategorized.length > 0) {
+    lines.push("### Other");
+    for (const n of uncategorized) {
+      lines.push(`- \`@/components/ui/${n}\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
 }
-`,
-  "next.config.js": `/** @type {import('next').NextConfig} */
-const nextConfig = {
-  output: 'standalone',
-  reactStrictMode: true,
+function toPascal(slug) {
+  return slug.split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
 }
+async function buildScaffoldAgentGuide(projectName, projectPath) {
+  const uiComponents = await listUiComponents(projectPath);
+  const uiCount = uiComponents.length;
+  const tokenTable = hslTokenRows().map((t) => `| ${t.name} | \`hsl(var(${t.varName}))\` | ${t.role} |`).join("\n");
+  const markdown = `# ${projectName} \u2014 FactorAI App Scaffold
 
-module.exports = nextConfig
-`,
-  "tailwind.config.ts": `import type { Config } from 'tailwindcss'
+> Dark command-center aesthetic: near-black canvas, high-contrast type, restrained accents. Default home is a **Refero-style landing** (hero, feature cards, nav) \u2014 customize \`app/page.tsx\` for your product.
 
-const config: Config = {
-  content: [
-    './pages/**/*.{js,ts,jsx,tsx,mdx}',
-    './components/**/*.{js,ts,jsx,tsx,mdx}',
-    './app/**/*.{js,ts,jsx,tsx,mdx}',
-  ],
-  theme: {
-    extend: {
-      backgroundImage: {
-        'gradient-radial': 'radial-gradient(var(--tw-gradient-stops))',
-        'gradient-conic':
-          'conic-gradient(from 180deg at 50% 50%, var(--tw-gradient-stops))',
-      },
-    },
-  },
-  plugins: [],
-}
-export default config
-`,
-  "postcss.config.js": `module.exports = {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}
-`,
-  ".eslintrc.json": `{
-  "extends": "next/core-web-vitals"
-}
-`,
-  ".gitignore": `# dependencies
-/node_modules
-/.pnp
-.pnp.js
+**Theme:** dark  
+**Stack:** Next.js 14 App Router \xB7 \`output: 'standalone'\` (FactorAI deploy) \xB7 Tailwind 3 \xB7 shadcn/ui (${uiCount} components)  
+**Path alias:** \`@/*\` \u2192 project root
 
-# testing
-/coverage
+---
 
-# next.js
-/.next/
-/out/
+## Architecture
 
-# production
-/build
+| Area | Path | Notes |
+|------|------|-------|
+| Home (starter UI) | \`app/page.tsx\` | Dark landing: hero glow, badge, CTAs, 3 feature cards, footer |
+| Root layout | \`app/layout.tsx\` | Metadata title = project name |
+| Global styles | \`app/globals.css\` | shadcn HSL tokens (see below) |
+| UI kit | \`components/ui/*\` | Same set as factorai.sh \u2014 import, do not recreate |
+| Utilities | \`lib/utils.ts\` | \`cn()\` for class merging |
+| Toasts | \`hooks/use-toast.ts\` | Pair with \`components/ui/toaster\` or \`sonner\` |
+| Config | \`next.config.js\`, \`tailwind.config.ts\` | Standalone build required for hosting |
 
-# misc
-.DS_Store
-*.pem
+---
 
-# debug
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
+## Tokens \u2014 Colors
 
-# local env files
-.env*.local
-.env
+| Name | Value | Role |
+|------|-------|------|
+${tokenTable}
 
-# typescript
-*.tsbuildinfo
-next-env.d.ts
-`,
-  // App Router mínimo (obrigatório para next build / deploy no Severino)
-  "app/layout.tsx": `import type { Metadata } from 'next';
-import './globals.css';
+Use Tailwind semantic classes (\`bg-background\`, \`text-muted-foreground\`, \`border-border\`) \u2014 not raw hex in JSX unless defining a one-off gradient.
 
-export const metadata: Metadata = {
-  title: '{{NAME}}',
-  description: 'Generated by create-next-app',
-};
+---
 
-export default function RootLayout({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  return (
-    <html lang="en">
-      <body>{children}</body>
-    </html>
-  );
-}
-`,
-  "app/page.tsx": `export default function Home() {
-  return (
-    <main className="flex min-h-screen flex-col items-center justify-center p-8">
-      <h1 className="text-2xl font-semibold">{{NAME}}</h1>
-      <p className="mt-2 text-sm text-gray-600">Next.js app ready for deploy.</p>
-    </main>
-  );
-}
-`,
-  "app/globals.css": `@tailwind base;
-@tailwind components;
-@tailwind utilities;
-`
-};
-var FULL_FILES = {
-  ...MINIMAL_FILES,
-  // App Router structure
-  "app/layout.tsx": `import type { Metadata } from "next";
-import { Inter } from "next/font/google";
-import "./globals.css";
-
-const inter = Inter({ subsets: ["latin"] });
-
-export const metadata: Metadata = {
-  title: "{{NAME}}",
-  description: "Generated by create-next-app",
-};
+## Tokens \u2014 Typography & spacing
 
-export default function RootLayout({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  return (
-    <html lang="en">
-      <body className={inter.className}>{children}</body>
-    </html>
-  );
-}
-`,
-  "app/page.tsx": `export default function Home() {
-  return (
-    <main className="flex min-h-screen flex-col items-center justify-between p-24">
-      <div className="z-10 w-full max-w-5xl items-center justify-between font-mono text-sm lg:flex">
-        <p className="fixed left-0 top-0 flex w-full justify-center border-b border-gray-300 bg-gradient-to-b from-zinc-200 pb-6 pt-8 backdrop-blur-2xl dark:border-neutral-800 dark:bg-zinc-800/30 dark:from-inherit lg:static lg:w-auto  lg:rounded-xl lg:border lg:bg-gray-200 lg:p-4 lg:dark:bg-zinc-800/30">
-          Welcome to <code className="font-mono font-bold">{{NAME}}</code>
-        </p>
-      </div>
-
-      <div className="mb-32 grid text-center lg:max-w-5xl lg:w-full lg:mb-0 lg:grid-cols-4 lg:text-left">
-        <a
-          href="https://nextjs.org/docs"
-          className="group rounded-lg border border-transparent px-5 py-4 transition-colors hover:border-gray-300 hover:bg-gray-100 hover:dark:border-neutral-700 hover:dark:bg-neutral-800/30"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          <h2 className={\`mb-3 text-2xl font-semibold\`}>
-            Docs{" "}
-            <span className="inline-block transition-transform group-hover:translate-x-1 motion-reduce:transform-none">
-              -&gt;
-            </span>
-          </h2>
-          <p className={\`m-0 max-w-[30ch] text-sm opacity-50\`}>
-            Find in-depth information about Next.js features and API.
-          </p>
-        </a>
-
-        <a
-          href="https://nextjs.org/learn"
-          className="group rounded-lg border border-transparent px-5 py-4 transition-colors hover:border-gray-300 hover:bg-gray-100 hover:dark:border-neutral-700 hover:dark:bg-neutral-800/30"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          <h2 className={\`mb-3 text-2xl font-semibold\`}>
-            Learn{" "}
-            <span className="inline-block transition-transform group-hover:translate-x-1 motion-reduce:transform-none">
-              -&gt;
-            </span>
-          </h2>
-          <p className={\`m-0 max-w-[30ch] text-sm opacity-50\`}>
-            Learn about Next.js in an interactive course with&nbsp;quizzes!
-          </p>
-        </a>
-
-        <a
-          href="https://vercel.com/templates"
-          className="group rounded-lg border border-transparent px-5 py-4 transition-colors hover:border-gray-300 hover:bg-gray-100 hover:dark:border-neutral-700 hover:dark:bg-neutral-800/30"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          <h2 className={\`mb-3 text-2xl font-semibold\`}>
-            Templates{" "}
-            <span className="inline-block transition-transform group-hover:translate-x-1 motion-reduce:transform-none">
-              -&gt;
-            </span>
-          </h2>
-          <p className={\`m-0 max-w-[30ch] text-sm opacity-50\`}>
-            Explore starter templates for Next.js.
-          </p>
-        </a>
-
-        <a
-          href="https://vercel.com/new"
-          className="group rounded-lg border border-transparent px-5 py-4 transition-colors hover:border-gray-300 hover:bg-gray-100 hover:dark:border-neutral-700 hover:dark:bg-neutral-800/30"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          <h2 className={\`mb-3 text-2xl font-semibold\`}>
-            Deploy{" "}
-            <span className="inline-block transition-transform group-hover:translate-x-1 motion-reduce:transform-none">
-              -&gt;
-            </span>
-          </h2>
-          <p className={\`m-0 max-w-[30ch] text-sm opacity-50 text-balance\`}>
-            Instantly deploy your Next.js site to a shareable URL with Vercel.
-          </p>
-        </a>
-      </div>
-    </main>
-  );
-}
-`,
-  "app/globals.css": `@tailwind base;
-@tailwind components;
-@tailwind utilities;
+- **Fonts:** system UI stack (add Inter/Geist in \`layout.tsx\` if you want a product-specific voice).
+- **Scale:** \`text-sm\` body, \`text-lg\`/\`text-xl\` subheads, \`text-3xl\`\u2013\`text-5xl\` hero with \`tracking-tight\`.
+- **Density:** comfortable \u2014 \`section\` gaps \`py-16\`\u2013\`py-24\`, card padding \`p-6\`, inline gaps \`gap-3\`/\`gap-4\`.
+- **Radius:** \`--radius: 0.5rem\` \u2014 buttons/inputs \`rounded-md\`, pills \`rounded-full\`.
 
-:root {
-  --foreground-rgb: 0, 0, 0;
-  --background-start-rgb: 214, 219, 220;
-  --background-end-rgb: 255, 255, 255;
-}
+---
 
-@media (prefers-color-scheme: dark) {
-  :root {
-    --foreground-rgb: 255, 255, 255;
-    --background-start-rgb: 0, 0, 0;
-    --background-end-rgb: 0, 0, 0;
-  }
-}
+## UI components available (${uiCount})
 
-body {
-  color: rgb(var(--foreground-rgb));
-  background: linear-gradient(
-      to bottom,
-      transparent,
-      rgb(var(--background-end-rgb))
-    )
-    rgb(var(--background-start-rgb));
-}
+Import from \`@/components/ui/<file>\`. Compose with \`cn()\` from \`@/lib/utils\`.
 
-@layer utilities {
-  .text-balance {
-    text-wrap: balance;
-  }
+${componentInventoryMarkdown(uiComponents)}
+
+**Quick import examples:**
+
+\`\`\`tsx
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+import { Badge } from "@/components/ui/badge";
+import { Separator } from "@/components/ui/separator";
+\`\`\`
+
+---
+
+## Do's and Don'ts (polished interfaces)
+
+### Do
+- Keep **one dominant background** (\`bg-background\`) and **one accent discipline** (primary buttons + ring on focus).
+- Use **clear hierarchy**: display headline \u2192 subheading (\`text-muted-foreground\`) \u2192 body; max width \`max-w-2xl\` or \`max-w-3xl\` for prose.
+- Build **sections** with \`py-16 md:py-24\` and centered containers \`mx-auto max-w-6xl px-4 md:px-6\`.
+- Prefer **Card** for feature groupings; use **ghost/outline** buttons for secondary actions.
+- Add **generous whitespace**; empty space signals quality (see [Refero Styles](https://styles.refero.design/) references).
+- Use **Sonner** or **Toast** for async feedback after deploy-worthy flows.
+- Run \`npm run build\` before deploy; keep standalone output intact.
+
+### Don't
+- Customize the default landing copy and sections for your product before production.
+- Keep the starter layout patterns (hero glow, pill buttons, card grid) when extending \u2014 do not regress to generic Next.js marketing grids.
+- Do not invent parallel design systems \u2014 use existing \`components/ui\` tokens.
+- Do not saturate the UI with many accent colors; stay monochromatic + primary/ destructive only.
+- Do not use tiny touch targets \u2014 buttons \`h-10\` minimum, adequate \`px-4\`.
+- Do not add new npm UI libraries without strong reason \u2014 kit is already complete.
+
+---
+
+## Layout patterns (recommended)
+
+1. **Hero:** full-width \`min-h-[80vh]\`, centered headline, single primary CTA, optional subtle gradient \`bg-gradient-to-b from-background to-muted/30\`.
+2. **Feature grid:** \`grid md:grid-cols-2 lg:grid-cols-3 gap-6\` of Cards.
+3. **Split section:** \`grid lg:grid-cols-2 gap-12 items-center\` text + visual.
+4. **Sticky nav:** \`border-b border-border/40 backdrop-blur\` bar with ghost nav + one filled CTA.
+
+---
+
+## Agent prompt guide (copy into your planning)
+
+**Quick color reference:** text \`text-foreground\`, background \`bg-background\`, borders \`border-border\`, primary CTA \`bg-primary text-primary-foreground\`.
+
+**Example prompts for this codebase:**
+
+1. *Hero:* \`min-h-screen bg-background flex flex-col items-center justify-center px-6\`. Headline \`text-4xl md:text-6xl font-medium tracking-tight text-foreground\`. Subtext \`text-muted-foreground text-lg mt-4 max-w-xl text-center\`. Primary \`Button\` mt-8.
+2. *Feature card:* \`Card\` with \`CardHeader\` + \`CardTitle\` + \`CardDescription\`; \`CardContent\` with short copy; optional \`Badge\` for labels.
+3. *Form block:* \`Input\` + \`Label\` in a \`Card\`; submit \`Button\` full width on mobile; inline \`text-sm text-muted-foreground\` helpers.
+
+For external visual direction, browse dark/productivity references on [Refero Styles](https://styles.refero.design/) (e.g. Linear, xAI, Stripe) \u2014 adapt tokens above, do not copy unrelated fonts wholesale.
+
+---
+
+## What to do next
+
+1. Edit \`app/page.tsx\` (and add routes under \`app/\` as needed).
+2. \`npm run dev\` \u2014 preview locally.
+3. \`factorai.sh.deploy_app\` when ready \u2014 ZIP excludes \`node_modules\` and \`.next\`.
+
+---
+
+*Generated by BluMa \`factorai.sh.create_next_app\` \xB7 re-read this file at \`${DESIGN_DOC_FILENAME}\` in the project root.*
+`;
+  return { markdown, uiComponents };
+}
+async function writeDesignDoc(projectPath, markdown) {
+  const docPath = path25.join(projectPath, DESIGN_DOC_FILENAME);
+  await fs23.writeFile(docPath, markdown, "utf-8");
+  return docPath;
 }
-`,
-  // shadcn/ui base components (sem @radix-ui/react-slot — evita falha de build no deploy)
-  "components/ui/button.tsx": `import * as React from "react"
-import { cva, type VariantProps } from "class-variance-authority"
-import { cn } from "@/lib/utils"
 
-const buttonVariants = cva(
-  "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-zinc-400 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
-  {
-    variants: {
-      variant: {
-        default: "bg-zinc-900 text-white hover:bg-zinc-800",
-        destructive: "bg-red-600 text-white hover:bg-red-700",
-        outline: "border border-zinc-200 bg-white hover:bg-zinc-50",
-        secondary: "bg-zinc-100 text-zinc-900 hover:bg-zinc-200",
-        ghost: "hover:bg-zinc-100",
-        link: "text-zinc-900 underline-offset-4 hover:underline",
-      },
-      size: {
-        default: "h-10 px-4 py-2",
-        sm: "h-9 rounded-md px-3",
-        lg: "h-11 rounded-md px-8",
-        icon: "h-10 w-10",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-)
-
-export interface ButtonProps
-  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
-    VariantProps<typeof buttonVariants> {}
-
-const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
-  ({ className, variant, size, ...props }, ref) => (
-    <button
-      className={cn(buttonVariants({ variant, size, className }))}
-      ref={ref}
-      {...props}
-    />
-  )
-)
-Button.displayName = "Button"
-
-export { Button, buttonVariants }
-`,
-  "components/ui/card.tsx": `import * as React from "react"
-import { cn } from "@/lib/utils"
-
-const Card = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement>
->(({ className, ...props }, ref) => (
-  <div
-    ref={ref}
-    className={cn(
-      "rounded-lg border border-zinc-200 bg-white text-zinc-950 shadow-sm",
-      className
-    )}
-    {...props}
-  />
-))
-Card.displayName = "Card"
-
-const CardHeader = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement>
->(({ className, ...props }, ref) => (
-  <div
-    ref={ref}
-    className={cn("flex flex-col space-y-1.5 p-6", className)}
-    {...props}
-  />
-))
-CardHeader.displayName = "CardHeader"
-
-const CardTitle = React.forwardRef<
-  HTMLParagraphElement,
-  React.HTMLAttributes<HTMLHeadingElement>
->(({ className, ...props }, ref) => (
-  <h3
-    ref={ref}
-    className={cn(
-      "text-2xl font-semibold leading-none tracking-tight",
-      className
-    )}
-    {...props}
-  />
-))
-CardTitle.displayName = "CardTitle"
-
-const CardDescription = React.forwardRef<
-  HTMLParagraphElement,
-  React.HTMLAttributes<HTMLParagraphElement>
->(({ className, ...props }, ref) => (
-  <p
-    ref={ref}
-    className={cn("text-sm text-zinc-500", className)}
-    {...props}
-  />
-))
-CardDescription.displayName = "CardDescription"
-
-const CardContent = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement>
->(({ className, ...props }, ref) => (
-  <div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
-))
-CardContent.displayName = "CardContent"
-
-const CardFooter = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement>
->(({ className, ...props }, ref) => (
-  <div
-    ref={ref}
-    className={cn("flex items-center p-6 pt-0", className)}
-    {...props}
-  />
-))
-CardFooter.displayName = "CardFooter"
-
-export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }
-`,
-  "components/ui/input.tsx": `import * as React from "react"
-import { cn } from "@/lib/utils"
-
-export interface InputProps
-  extends React.InputHTMLAttributes<HTMLInputElement> {}
-
-const Input = React.forwardRef<HTMLInputElement, InputProps>(
-  ({ className, type, ...props }, ref) => {
-    return (
-      <input
-        type={type}
-        className={cn(
-          "flex h-10 w-full rounded-md border border-zinc-200 bg-white px-3 py-2 text-sm file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-zinc-400 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-zinc-400 focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
-          className
-        )}
-        ref={ref}
-        {...props}
-      />
-    )
-  }
-)
-Input.displayName = "Input"
-
-export { Input }
-`,
-  "lib/utils.ts": `import { type ClassValue, clsx } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}
-`,
-  // Add clsx and tailwind-merge to package.json dependencies
-  "package.json.full": `{
-  "name": "{{NAME}}",
-  "version": "0.1.0",
-  "private": true,
-  "scripts": {
-    "dev": "next dev",
-    "build": "next build",
-    "start": "next start",
-    "lint": "next lint"
-  },
-  "dependencies": {
-    "next": "^14.1.0",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "class-variance-authority": "^0.7.0",
-    "clsx": "^2.1.0",
-    "tailwind-merge": "^2.2.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.11.0",
-    "@types/react": "^18.2.0",
-    "@types/react-dom": "^18.2.0",
-    "typescript": "^5.3.0",
-    "tailwindcss": "^3.4.0",
-    "postcss": "^8.4.0",
-    "autoprefixer": "^10.4.0",
-    "eslint": "^8.56.0",
-    "eslint-config-next": "^14.1.0"
+// src/app/agent/tools/CreateNextAppTool/CreateNextAppTool.ts
+var SCAFFOLD_DIR = path26.join(
+  path26.dirname(fileURLToPath(import.meta.url)),
+  "scaffold"
+);
+async function copyScaffoldTree(projectPath, projectName) {
+  const filesCreated = [];
+  async function walk(relativeDir) {
+    const srcDir = path26.join(SCAFFOLD_DIR, relativeDir);
+    const entries = await fs24.readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const relPath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+      const srcPath = path26.join(SCAFFOLD_DIR, relPath);
+      const destPath = path26.join(projectPath, relPath);
+      if (entry.isDirectory()) {
+        await fs24.mkdir(destPath, { recursive: true });
+        await walk(relPath);
+        continue;
+      }
+      const raw = await fs24.readFile(srcPath, "utf-8");
+      const content = raw.replace(/\{\{NAME\}\}/g, projectName);
+      await fs24.mkdir(path26.dirname(destPath), { recursive: true });
+      await fs24.writeFile(destPath, content, "utf-8");
+      filesCreated.push(relPath);
+    }
   }
-}
-`
-};
-async function createFile(filePath, content, projectName) {
-  const dir = path25.dirname(filePath);
-  await fs23.mkdir(dir, { recursive: true });
-  const replacedContent = content.replace(/{{NAME}}/g, projectName);
-  await fs23.writeFile(filePath, replacedContent, "utf-8");
+  await walk("");
+  return filesCreated;
 }
 async function createNextApp(args) {
-  const {
-    name,
-    directory,
-    template = "full"
-  } = args;
+  const { name, directory } = args;
   try {
     if (!name || typeof name !== "string") {
       return { success: false, error: "name is required and must be a string" };
@@ -19487,73 +19243,66 @@ async function createNextApp(args) {
       };
     }
     const baseDir = directory ? resolveWorkspacePath(directory) : resolveWorkspacePath(".");
-    const projectPath = path25.join(baseDir, name);
+    const projectPath = path26.join(baseDir, name);
     try {
-      await fs23.access(projectPath);
+      await fs24.access(projectPath);
       return {
         success: false,
         error: `Directory already exists: ${projectPath}. Remove it first or choose a different name.`
       };
     } catch {
     }
-    await fs23.mkdir(projectPath, { recursive: true });
-    const filesToCreate = template === "minimal" ? MINIMAL_FILES : FULL_FILES;
-    const filesCreated = [];
-    for (const [relativePath, content] of Object.entries(filesToCreate)) {
-      if (relativePath === "package.json.full") continue;
-      const fullPath = path25.join(projectPath, relativePath);
-      await createFile(fullPath, content, name);
-      filesCreated.push(relativePath);
-    }
-    if (template === "full") {
-      const packageJsonPath = path25.join(projectPath, "package.json");
-      const fullPackageJson = FULL_FILES["package.json.full"];
-      if (fullPackageJson) {
-        await createFile(packageJsonPath, fullPackageJson, name);
-      }
-    }
+    await fs24.mkdir(projectPath, { recursive: true });
+    const filesCreated = await copyScaffoldTree(projectPath, name);
     console.log(`[create-next-app] Installing dependencies in ${projectPath}...`);
     const installResult = await shellCommand({
       command: "npm install",
       cwd: projectPath,
       timeout: 300
-      // 5 minutos
     });
     const installJson = JSON.parse(installResult);
     if (installJson.status !== "success") {
       console.warn("[create-next-app] npm install warnings:", installJson.stderr);
     }
+    const { markdown: agentGuide, uiComponents } = await buildScaffoldAgentGuide(
+      name,
+      projectPath
+    );
+    const designDocPath = await writeDesignDoc(projectPath, agentGuide);
     const nextSteps = [
-      `cd ${name}`,
-      "npm run dev",
-      "Open http://localhost:3000",
-      template === "full" ? "Components shadcn/ui dispon\xEDveis em components/ui/" : "Adicione componentes conforme necess\xE1rio"
+      `Read ${DESIGN_DOC_FILENAME} (or tool result agentGuide) before editing UI`,
+      `cd ${name} && npm run dev \u2014 default landing shows "Power by FactorAI"`,
+      `Edit app/page.tsx; use @/components/ui/* (${uiComponents.length} components)`,
+      "Deploy with factorai.sh.deploy_app when ready"
     ];
+    const summary = `Created "${name}" at ${projectPath}: Next.js 14 + ${uiComponents.length} shadcn/ui components, dark FactorAI tokens, standalone deploy. Default landing is ready \u2014 customize app/page.tsx for your product.`;
     console.log(`[create-next-app] Projeto criado: ${projectPath}`);
     return {
       success: true,
       projectPath,
       directory: name,
       filesCreated,
+      agentGuide,
+      designDocPath,
+      uiComponentCount: uiComponents.length,
+      summary,
       nextSteps
     };
   } catch (error) {
-    console.error("[create-next-app] Error:", error.message);
-    return {
-      success: false,
-      error: error.message || String(error)
-    };
+    const message2 = error instanceof Error ? error.message : String(error);
+    console.error("[create-next-app] Error:", message2);
+    return { success: false, error: message2 };
   }
 }
 
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 init_sandbox_policy();
-import { promises as fs24 } from "fs";
-import path27 from "path";
+import { promises as fs25 } from "fs";
+import path28 from "path";
 
 // src/app/agent/tools/DeployAppTool/createDeployProjectZip.ts
 import { lstat, readdir, readFile as readFile2, writeFile } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 import { minimatch as minimatch2 } from "minimatch";
 var DEPLOY_ZIP_EXCLUDE_PATTERNS = [
   "node_modules",
@@ -19578,7 +19327,7 @@ function shouldExcludeFromDeployZip(relativePosix, isDirectory) {
   const rel = relativePosix.replace(/\\/g, "/").replace(/^\.\//, "");
   if (!rel) return false;
   const segments = pathSegments(rel);
-  const baseName = path26.posix.basename(rel);
+  const baseName = path27.posix.basename(rel);
   for (const pattern of DEPLOY_ZIP_EXCLUDE_PATTERNS) {
     if (pattern.includes("*")) {
       if (minimatch2(rel, pattern) || minimatch2(baseName, pattern)) {
@@ -19596,7 +19345,7 @@ function shouldExcludeFromDeployZip(relativePosix, isDirectory) {
   return false;
 }
 async function collectDeployZipEntries(projectDir, files) {
-  const base = path26.resolve(projectDir);
+  const base = path27.resolve(projectDir);
   async function walk(currentDir) {
     let entries;
     try {
@@ -19605,8 +19354,8 @@ async function collectDeployZipEntries(projectDir, files) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path26.join(currentDir, entry.name);
-      const rel = path26.relative(base, fullPath).replace(/\\/g, "/");
+      const fullPath = path27.join(currentDir, entry.name);
+      const rel = path27.relative(base, fullPath).replace(/\\/g, "/");
       if (shouldExcludeFromDeployZip(rel, entry.isDirectory())) {
         continue;
       }
@@ -19650,12 +19399,12 @@ async function createDeployProjectZip(projectDir, zipPath) {
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
   const deployUrl = `${severinoUrl.replace(/\/$/, "")}/api/v1/deploy`;
-  const zipBytes = await fs24.readFile(zipPath);
+  const zipBytes = await fs25.readFile(zipPath);
   const form = new FormData();
   form.append(
     "file",
     new Blob([zipBytes], { type: "application/zip" }),
-    path27.basename(zipPath)
+    path28.basename(zipPath)
   );
   if (name) form.append("name", name);
   if (appId) form.append("appId", appId);
@@ -19764,8 +19513,8 @@ function buildFactorAiManifest(appContext, deployResult, appName) {
 }
 async function writeFactorAiManifest(projectDir, appContext, deployResult, appName) {
   const manifest = buildFactorAiManifest(appContext, deployResult, appName);
-  const manifestPath = path27.join(projectDir, "factorai.sh.json");
-  await fs24.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  const manifestPath = path28.join(projectDir, "factorai.sh.json");
+  await fs25.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   return manifest;
 }
@@ -19785,23 +19534,23 @@ async function deployApp(args) {
     }
     const resolvedProjectDir = resolveWorkspacePath(projectDir);
     try {
-      await fs24.access(resolvedProjectDir);
+      await fs25.access(resolvedProjectDir);
     } catch {
       return {
         success: false,
         error: `Project directory not found: ${resolvedProjectDir}`
       };
     }
-    const packageJsonPath = path27.join(resolvedProjectDir, "package.json");
+    const packageJsonPath = path28.join(resolvedProjectDir, "package.json");
     try {
-      await fs24.access(packageJsonPath);
+      await fs25.access(packageJsonPath);
     } catch {
       return {
         success: false,
         error: "Not a Next.js project: package.json not found"
       };
     }
-    const packageJsonContent = await fs24.readFile(packageJsonPath, "utf-8");
+    const packageJsonContent = await fs25.readFile(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     const hasNext = packageJson.dependencies?.next || packageJson.devDependencies?.next;
     if (!hasNext) {
@@ -19810,18 +19559,18 @@ async function deployApp(args) {
         error: "Not a Next.js project: next not found in dependencies"
       };
     }
-    const appName = name || packageJson.name || path27.basename(resolvedProjectDir);
-    const tempDir = path27.join(resolvedProjectDir, ".tmp");
-    await fs24.mkdir(tempDir, { recursive: true });
-    const zipPath = path27.join(tempDir, `${appName}-${Date.now()}.zip`);
+    const appName = name || packageJson.name || path28.basename(resolvedProjectDir);
+    const tempDir = path28.join(resolvedProjectDir, ".tmp");
+    await fs25.mkdir(tempDir, { recursive: true });
+    const zipPath = path28.join(tempDir, `${appName}-${Date.now()}.zip`);
     console.log(`[deploy-app] Creating ZIP: ${zipPath}`);
     await createDeployProjectZip(resolvedProjectDir, zipPath);
-    const zipStats = await fs24.stat(zipPath);
+    const zipStats = await fs25.stat(zipPath);
     const zipSizeMB = zipStats.size / 1024 / 1024;
     if (zipSizeMB > 50) {
-      await fs24.unlink(zipPath).catch(() => {
+      await fs25.unlink(zipPath).catch(() => {
       });
-      await fs24.rmdir(tempDir).catch(() => {
+      await fs25.rmdir(tempDir).catch(() => {
       });
       return {
         success: false,
@@ -19832,8 +19581,8 @@ async function deployApp(args) {
     console.log(`[deploy-app] Uploading to ${severinoUrl}...`);
     const deployResult = await uploadToSeverino(zipPath, severinoUrl, appName, apiKey, appId);
     try {
-      await fs24.unlink(zipPath);
-      await fs24.rmdir(tempDir);
+      await fs25.unlink(zipPath);
+      await fs25.rmdir(tempDir);
     } catch (e) {
       console.warn("[deploy-app] Cleanup warning:", e);
     }
@@ -19846,7 +19595,7 @@ async function deployApp(args) {
           appName
         );
         deployResult.factoraiManifest = manifest;
-        deployResult.factoraiManifestPath = path27.join(resolvedProjectDir, "factorai.sh.json");
+        deployResult.factoraiManifestPath = path28.join(resolvedProjectDir, "factorai.sh.json");
       }
       console.log(`[deploy-app] Deploy iniciado: ${deployResult.appId}`);
     }
@@ -19994,12 +19743,11 @@ function getFactorAiSandboxToolDefinitions() {
       type: "function",
       function: {
         name: "factorai.sh.create_next_app",
-        description: "Create a new Next.js project in the sandbox workspace for FactorAI deployments.",
+        description: "Create a Next.js 14 project (App Router, standalone, full shadcn/ui kit). Returns agentGuide (Refero-style DESIGN brief: tokens, UI inventory, do/don't) and writes DESIGN.md \u2014 read agentGuide before editing UI.",
         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"],
@@ -20672,7 +20420,7 @@ var NATIVE_TOOL_ENTRIES = [
       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)."
+      description: "Create Next.js 14 + full shadcn/ui kit. Returns agentGuide + DESIGN.md. Default page: polished dark landing (Refero-style) \u2014 read agentGuide before extending UI."
     },
     implementation: createNextApp
   },
@@ -20927,10 +20675,10 @@ var ToolInvoker = class {
    */
   async initialize() {
     try {
-      const currentFilePath = fileURLToPath(import.meta.url);
-      const currentDirPath = path28.dirname(currentFilePath);
-      const configPath = path28.resolve(currentDirPath, "config", "native_tools.json");
-      const fileContent = await fs25.readFile(configPath, "utf-8");
+      const currentFilePath = fileURLToPath2(import.meta.url);
+      const currentDirPath = path29.dirname(currentFilePath);
+      const configPath = path29.resolve(currentDirPath, "config", "native_tools.json");
+      const fileContent = await fs26.readFile(configPath, "utf-8");
       const config3 = JSON.parse(fileContent);
       this.toolDefinitions = applyMetadataToToolDefinitions(config3.nativeTools);
       const sandboxOnlyTools = applyMetadataToToolDefinitions(getSandboxOnlyNativeToolDefinitions());
@@ -20977,10 +20725,10 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs26 } from "fs";
-import path29 from "path";
+import { promises as fs27 } from "fs";
+import path30 from "path";
 import os19 from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 var MCPClient = class {
@@ -21005,10 +20753,10 @@ var MCPClient = class {
         originalName: toolName
       });
     }
-    const __filename = fileURLToPath2(import.meta.url);
-    const __dirname2 = path29.dirname(__filename);
-    const defaultConfigPath = path29.resolve(__dirname2, "config", "bluma-mcp.json");
-    const userConfigPath = path29.join(os19.homedir(), ".bluma", "bluma-mcp.json");
+    const __filename = fileURLToPath3(import.meta.url);
+    const __dirname2 = path30.dirname(__filename);
+    const defaultConfigPath = path30.resolve(__dirname2, "config", "bluma-mcp.json");
+    const userConfigPath = path30.join(os19.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -21042,7 +20790,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) {
@@ -21254,24 +21002,24 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path44 from "path";
-import fs39 from "fs";
+import path45 from "path";
+import fs40 from "fs";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path32 from "path";
-import { promises as fs29 } from "fs";
+import path33 from "path";
+import { promises as fs30 } from "fs";
 
 // src/app/agent/session_manager/agent_session_paths.ts
 init_bluma_app_dir();
-import path31 from "path";
-import { promises as fs28 } from "fs";
+import path32 from "path";
+import { promises as fs29 } from "fs";
 
 // src/app/agent/session_manager/session_index_db.ts
 init_bluma_app_dir();
-import path30 from "path";
+import path31 from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
-import { promises as fs27 } from "fs";
+import { promises as fs28 } from "fs";
 import { createRequire } from "module";
 var AGENT_SESSION_PATHS_JSONL = "agent_session_paths.jsonl";
 var BLUMA_SESSION_DB_FILE = "bluma.sqlite";
@@ -21284,21 +21032,21 @@ function loadSqlite() {
   return nodeRequire("better-sqlite3");
 }
 function getSessionDbPath(appDir = getPreferredAppDir()) {
-  return path30.join(appDir, BLUMA_SESSION_DB_FILE);
+  return path31.join(appDir, BLUMA_SESSION_DB_FILE);
 }
 function normalizeRelativePath(relativePath) {
-  return relativePath.split(path30.sep).join("/");
+  return relativePath.split(path31.sep).join("/");
 }
 async function walkSessionJsonFiles(dir, onFile) {
   let entries;
   try {
-    entries = await fs27.readdir(dir, { withFileTypes: true });
+    entries = await fs28.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path30.join(dir, name);
+    const full = path31.join(dir, name);
     if (e.isDirectory()) {
       await walkSessionJsonFiles(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -21308,10 +21056,10 @@ async function walkSessionJsonFiles(dir, onFile) {
 }
 async function loadJsonlEntries(appDir) {
   const map = /* @__PURE__ */ new Map();
-  const indexFile = path30.join(appDir, AGENT_SESSION_PATHS_JSONL);
+  const indexFile = path31.join(appDir, AGENT_SESSION_PATHS_JSONL);
   let raw;
   try {
-    raw = await fs27.readFile(indexFile, "utf-8");
+    raw = await fs28.readFile(indexFile, "utf-8");
   } catch {
     return map;
   }
@@ -21350,7 +21098,7 @@ async function readSessionMetaFromJson(absPath) {
     updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
   };
   try {
-    const raw = await fs27.readFile(absPath, "utf-8");
+    const raw = await fs28.readFile(absPath, "utf-8");
     const data = JSON.parse(raw);
     const createdAt = data.created_at ?? fallback.createdAt;
     const updatedAt = data.last_updated ?? data.created_at ?? fallback.updatedAt;
@@ -21361,7 +21109,7 @@ async function readSessionMetaFromJson(absPath) {
     };
   } catch {
     try {
-      const st = await fs27.stat(absPath);
+      const st = await fs28.stat(absPath);
       const iso = new Date(st.mtimeMs).toISOString();
       return { preview: fallback.preview, createdAt: iso, updatedAt: iso };
     } catch {
@@ -21388,7 +21136,7 @@ async function runMigrationV1(db, appDir) {
   const insertFromPath = async (sessionId, absPath, jsonlUpdatedAt) => {
     let rel;
     try {
-      rel = normalizeRelativePath(path30.relative(appDir, absPath));
+      rel = normalizeRelativePath(path31.relative(appDir, absPath));
     } catch {
       return;
     }
@@ -21403,9 +21151,9 @@ async function runMigrationV1(db, appDir) {
     });
   };
   for (const [sessionId, entry] of jsonl) {
-    const full = path30.join(appDir, entry.relativePath.replace(/\//g, path30.sep));
+    const full = path31.join(appDir, entry.relativePath.replace(/\//g, path31.sep));
     try {
-      await fs27.access(full);
+      await fs28.access(full);
       await insertFromPath(sessionId, full, entry.updatedAt);
     } catch {
       upsert.run({
@@ -21417,11 +21165,11 @@ async function runMigrationV1(db, appDir) {
       });
     }
   }
-  const sessionsRoot = path30.join(appDir, "sessions");
+  const sessionsRoot = path31.join(appDir, "sessions");
   const existing = db.prepare("SELECT session_id FROM agent_sessions").all();
   const seen = new Set(existing.map((r) => r.session_id));
   await walkSessionJsonFiles(sessionsRoot, async (absPath) => {
-    const sessionId = path30.basename(absPath, ".json");
+    const sessionId = path31.basename(absPath, ".json");
     if (!sessionId || seen.has(sessionId)) return;
     seen.add(sessionId);
     await insertFromPath(sessionId, absPath);
@@ -21456,7 +21204,7 @@ async function ensureSessionIndexDb(appDir = getPreferredAppDir()) {
       }
       const BetterSqlite3 = loadSqlite();
       const dbPath = getSessionDbPath(appDir);
-      mkdirSync3(path30.dirname(dbPath), { recursive: true });
+      mkdirSync3(path31.dirname(dbPath), { recursive: true });
       const db = new BetterSqlite3(dbPath);
       db.pragma("journal_mode = WAL");
       applySchema(db);
@@ -21492,7 +21240,7 @@ async function upsertSessionIndexRow(row, appDir = getPreferredAppDir()) {
 async function getSessionPathFromIndex(sessionId, appDir = getPreferredAppDir()) {
   const db = await ensureSessionIndexDb(appDir);
   const row = db.prepare("SELECT relative_path FROM agent_sessions WHERE session_id = ?").get(sessionId);
-  return row?.relative_path?.replace(/\//g, path30.sep) ?? null;
+  return row?.relative_path?.replace(/\//g, path31.sep) ?? null;
 }
 async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir()) {
   const db = await ensureSessionIndexDb(appDir);
@@ -21504,7 +21252,7 @@ async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir())
   ).all(limit);
   return rows.map((r) => ({
     sessionId: r.session_id,
-    relativePath: r.relative_path.replace(/\//g, path30.sep),
+    relativePath: r.relative_path.replace(/\//g, path31.sep),
     createdAt: r.created_at,
     updatedAt: r.updated_at,
     preview: r.preview
@@ -21516,7 +21264,7 @@ var AGENT_SESSION_PATHS_JSONL2 = "agent_session_paths.jsonl";
 async function appendAgentSessionPath(sessionId, relativePath) {
   const app = getPreferredAppDir();
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const rel = relativePath.split(path31.sep).join("/");
+  const rel = relativePath.split(path32.sep).join("/");
   await upsertSessionIndexRow({
     sessionId,
     relativePath: rel,
@@ -21526,10 +21274,10 @@ async function appendAgentSessionPath(sessionId, relativePath) {
   });
 }
 async function resolveSessionRelativePathFromJsonl(sessionId) {
-  const indexFile = path31.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path32.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   let raw;
   try {
-    raw = await fs28.readFile(indexFile, "utf-8");
+    raw = await fs29.readFile(indexFile, "utf-8");
   } catch {
     return null;
   }
@@ -21538,7 +21286,7 @@ async function resolveSessionRelativePathFromJsonl(sessionId) {
     try {
       const row = JSON.parse(lines[i]);
       if (row.sessionId === sessionId && typeof row.relativePath === "string") {
-        return row.relativePath.replace(/\//g, path31.sep);
+        return row.relativePath.replace(/\//g, path32.sep);
       }
     } catch {
     }
@@ -21553,13 +21301,13 @@ async function resolveSessionRelativePathFromIndex(sessionId) {
 async function walkSessionJsonFiles2(dir, onFile) {
   let entries;
   try {
-    entries = await fs28.readdir(dir, { withFileTypes: true });
+    entries = await fs29.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path31.join(dir, name);
+    const full = path32.join(dir, name);
     if (e.isDirectory()) {
       await walkSessionJsonFiles2(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -21568,12 +21316,12 @@ async function walkSessionJsonFiles2(dir, onFile) {
   }
 }
 async function findSessionFileGlobFallback(sessionId) {
-  const sessionsRoot = path31.join(getPreferredAppDir(), "sessions");
+  const sessionsRoot = path32.join(getPreferredAppDir(), "sessions");
   const state2 = { best: null };
   await walkSessionJsonFiles2(sessionsRoot, async (abs) => {
-    if (path31.basename(abs, ".json") !== sessionId) return;
+    if (path32.basename(abs, ".json") !== sessionId) return;
     try {
-      const st = await fs28.stat(abs);
+      const st = await fs29.stat(abs);
       if (!st.isFile()) return;
       if (!state2.best || st.mtimeMs > state2.best.m) {
         state2.best = { p: abs, m: st.mtimeMs };
@@ -21584,11 +21332,11 @@ async function findSessionFileGlobFallback(sessionId) {
   return state2.best !== null ? state2.best.p : null;
 }
 async function loadLatestIndexEntriesBySessionId() {
-  const indexFile = path31.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path32.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   const map = /* @__PURE__ */ new Map();
   let raw;
   try {
-    raw = await fs28.readFile(indexFile, "utf-8");
+    raw = await fs29.readFile(indexFile, "utf-8");
   } catch {
     return map;
   }
@@ -21624,11 +21372,11 @@ function dateFolderFromRelativePath(relativePath) {
 async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs, opts) {
   let rel;
   try {
-    rel = path31.relative(getPreferredAppDir(), absPath);
+    rel = path32.relative(getPreferredAppDir(), absPath);
   } catch {
     rel = absPath;
   }
-  const dateFolder = dateFolderFromRelativePath(rel.split(path31.sep).join("/"));
+  const dateFolder = dateFolderFromRelativePath(rel.split(path32.sep).join("/"));
   let preview = opts?.preview ?? "(no messages)";
   let lastActivityMs = lastMtimeMs;
   if (opts?.updatedAtIso) {
@@ -21639,7 +21387,7 @@ async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs, opts) {
   }
   if (!opts?.preview || opts.preview === "(no messages)") {
     try {
-      const raw = await fs28.readFile(absPath, "utf-8");
+      const raw = await fs29.readFile(absPath, "utf-8");
       const data = JSON.parse(raw);
       preview = previewFromConversationHistory(data.conversation_history);
       const iso = data.last_updated || data.created_at;
@@ -21667,9 +21415,9 @@ async function listAgentSessionsForResume(limit = 50) {
   const fromIndex = await listSessionsFromIndex(limit * 2, appDir);
   const map = /* @__PURE__ */ new Map();
   for (const row of fromIndex) {
-    const full = path31.join(appDir, row.relativePath);
+    const full = path32.join(appDir, row.relativePath);
     try {
-      const st = await fs28.stat(full);
+      const st = await fs29.stat(full);
       if (!st.isFile()) continue;
       map.set(row.sessionId, {
         path: full,
@@ -21680,12 +21428,12 @@ async function listAgentSessionsForResume(limit = 50) {
     } catch {
     }
   }
-  const sessionsRoot = path31.join(appDir, "sessions");
+  const sessionsRoot = path32.join(appDir, "sessions");
   await walkSessionJsonFiles2(sessionsRoot, async (absPath) => {
-    const id = path31.basename(absPath, ".json");
+    const id = path32.basename(absPath, ".json");
     if (!id) return;
     try {
-      const st = await fs28.stat(absPath);
+      const st = await fs29.stat(absPath);
       if (!st.isFile()) return;
       const cur = map.get(id);
       if (!cur || st.mtimeMs > cur.lastMtimeMs) {
@@ -21697,9 +21445,9 @@ async function listAgentSessionsForResume(limit = 50) {
   const index = await loadLatestIndexEntriesBySessionId();
   for (const [sessionId, entry] of index) {
     if (map.has(sessionId)) continue;
-    const full = path31.join(appDir, entry.relativePath.replace(/\//g, path31.sep));
+    const full = path32.join(appDir, entry.relativePath.replace(/\//g, path32.sep));
     try {
-      const st = await fs28.stat(full);
+      const st = await fs29.stat(full);
       if (st.isFile()) {
         map.set(sessionId, { path: full, lastMtimeMs: st.mtimeMs });
       }
@@ -21758,10 +21506,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path32.dirname(dest);
-      await fs29.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path33.dirname(dest);
+      await fs30.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs29.rename(src, dest);
+      await fs30.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -21774,13 +21522,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs29.access(src);
-    const data = await fs29.readFile(src);
-    const dir = path32.dirname(dest);
-    await fs29.mkdir(dir, { recursive: true }).catch(() => {
+    await fs30.access(src);
+    const data = await fs30.readFile(src);
+    const dir = path33.dirname(dest);
+    await fs30.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs29.writeFile(dest, data);
-    await fs29.unlink(src).catch(() => {
+    await fs30.writeFile(dest, data);
+    await fs30.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -21793,23 +21541,23 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path32.join(appDir, "sessions");
-  await fs29.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path33.join(appDir, "sessions");
+  await fs30.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function resolveAgentSessionFilePath(sessionId) {
   const appDir = getPreferredAppDir();
-  const legacy = path32.join(appDir, "sessions", `${sessionId}.json`);
+  const legacy = path33.join(appDir, "sessions", `${sessionId}.json`);
   try {
-    await fs29.access(legacy);
+    await fs30.access(legacy);
     return legacy;
   } catch {
   }
   const rel = await resolveSessionRelativePathFromIndex(sessionId);
   if (rel) {
-    const full = path32.join(appDir, rel);
+    const full = path33.join(appDir, rel);
     try {
-      await fs29.access(full);
+      await fs30.access(full);
       return full;
     } catch {
     }
@@ -21822,7 +21570,7 @@ async function loadSession(sessionId) {
     return null;
   }
   try {
-    const fileContent = await fs29.readFile(sessionFile, "utf-8");
+    const fileContent = await fs30.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     const memory = {
       historyAnchor: sessionData.history_anchor ?? null,
@@ -21843,16 +21591,16 @@ async function loadOrcreateSession(sessionId) {
   const y = String(now2.getFullYear());
   const mo = String(now2.getMonth() + 1).padStart(2, "0");
   const d = String(now2.getDate()).padStart(2, "0");
-  const datedDir = path32.join(sessionsRoot, y, mo, d);
-  await fs29.mkdir(datedDir, { recursive: true });
-  const sessionFile = path32.join(datedDir, `${sessionId}.json`);
+  const datedDir = path33.join(sessionsRoot, y, mo, d);
+  await fs30.mkdir(datedDir, { recursive: true });
+  const sessionFile = path33.join(datedDir, `${sessionId}.json`);
   const newSessionData = {
     session_id: sessionId,
     created_at: now2.toISOString(),
     conversation_history: []
   };
-  await fs29.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
-  const relToApp = path32.relative(getPreferredAppDir(), sessionFile);
+  await fs30.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+  const relToApp = path33.relative(getPreferredAppDir(), sessionFile);
   await appendAgentSessionPath(sessionId, relToApp);
   const emptyMemory = {
     historyAnchor: null,
@@ -21864,12 +21612,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path32.dirname(sessionFile);
-      await fs29.mkdir(dir, { recursive: true });
+      const dir = path33.dirname(sessionFile);
+      await fs30.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs29.readFile(sessionFile, "utf-8");
+      const fileContent = await fs30.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -21880,14 +21628,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path32.basename(sessionFile, ".json");
+      const sessionId = path33.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs29.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs30.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -21903,14 +21651,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     }
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs29.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs30.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
-      const sessionId = sessionData.session_id ?? path32.basename(sessionFile, ".json");
+      const sessionId = sessionData.session_id ?? path33.basename(sessionFile, ".json");
       const updatedAt = sessionData.last_updated ?? (/* @__PURE__ */ new Date()).toISOString();
       const createdAt = sessionData.created_at ?? updatedAt;
       let relToApp;
       try {
-        relToApp = path32.relative(getPreferredAppDir(), sessionFile);
+        relToApp = path33.relative(getPreferredAppDir(), sessionFile);
       } catch {
         relToApp = sessionFile;
       }
@@ -21930,7 +21678,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs29.unlink(tempSessionFile);
+        await fs30.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -21962,15 +21710,15 @@ async function saveSessionHistoryNow(sessionFile, history, memory) {
 
 // src/app/agent/core/prompt/prompt_builder.ts
 import os23 from "os";
-import fs35 from "fs";
-import path38 from "path";
+import fs36 from "fs";
+import path39 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs30 from "fs";
-import path33 from "path";
+import fs31 from "fs";
+import path34 from "path";
 import os20 from "os";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 var SkillLoader = class _SkillLoader {
   bundledSkillsDir;
   projectSkillsDir;
@@ -21978,8 +21726,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path33.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path33.join(os20.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path34.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path34.join(os20.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -21988,48 +21736,48 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path33.join(process.cwd(), "dist", "config", "skills");
+      return path34.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path33.resolve(p);
+      const abs = path34.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path33.dirname(fileURLToPath3(import.meta.url));
-      push(path33.join(bundleDir, "config", "skills"));
+      const bundleDir = path34.dirname(fileURLToPath4(import.meta.url));
+      push(path34.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path33.isAbsolute(argv1) && fs30.existsSync(argv1)) {
-          resolved = fs30.realpathSync(argv1);
-        } else if (!path33.isAbsolute(argv1)) {
-          resolved = path33.resolve(process.cwd(), argv1);
+        if (path34.isAbsolute(argv1) && fs31.existsSync(argv1)) {
+          resolved = fs31.realpathSync(argv1);
+        } else if (!path34.isAbsolute(argv1)) {
+          resolved = path34.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path33.dirname(resolved);
-        argvBundled = path33.join(scriptDir, "config", "skills");
+        const scriptDir = path34.dirname(resolved);
+        argvBundled = path34.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
     }
     for (const abs of candidates) {
-      if (fs30.existsSync(abs)) {
+      if (fs31.existsSync(abs)) {
         return abs;
       }
     }
     try {
-      return path33.join(path33.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
+      return path34.join(path34.dirname(fileURLToPath4(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path33.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path34.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -22058,8 +21806,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path33.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path33.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path34.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path34.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -22067,20 +21815,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs30.existsSync(dir)) return [];
+    if (!fs31.existsSync(dir)) return [];
     try {
-      return fs30.readdirSync(dir).filter((d) => {
-        const fullPath = path33.join(dir, d);
-        return fs30.statSync(fullPath).isDirectory() && fs30.existsSync(path33.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path33.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs31.readdirSync(dir).filter((d) => {
+        const fullPath = path34.join(dir, d);
+        return fs31.statSync(fullPath).isDirectory() && fs31.existsSync(path34.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path34.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs30.existsSync(skillPath)) return null;
+    if (!fs31.existsSync(skillPath)) return null;
     try {
-      const raw = fs30.readFileSync(skillPath, "utf-8");
+      const raw = fs31.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -22102,12 +21850,12 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path33.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path33.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path33.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs30.existsSync(bundledPath);
-    const existsProject = fs30.existsSync(projectPath);
-    const existsGlobal = fs30.existsSync(globalPath);
+    const bundledPath = path34.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path34.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path34.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs31.existsSync(bundledPath);
+    const existsProject = fs31.existsSync(projectPath);
+    const existsGlobal = fs31.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -22146,9 +21894,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs30.readFileSync(skillPath, "utf-8");
+      const raw = fs31.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path33.dirname(skillPath);
+      const skillDir = path34.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -22157,22 +21905,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path33.join(skillDir, "references")),
-        scripts: this.scanAssets(path33.join(skillDir, "scripts"))
+        references: this.scanAssets(path34.join(skillDir, "references")),
+        scripts: this.scanAssets(path34.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs30.existsSync(dir)) return [];
+    if (!fs31.existsSync(dir)) return [];
     try {
-      return fs30.readdirSync(dir).filter((f) => {
-        const fp = path33.join(dir, f);
-        return fs30.statSync(fp).isFile();
+      return fs31.readdirSync(dir).filter((f) => {
+        const fp = path34.join(dir, f);
+        return fs31.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path33.resolve(dir, f)
+        path: path34.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -22229,10 +21977,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path33.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path33.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path33.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs30.existsSync(bundledPath) || fs30.existsSync(projectPath) || fs30.existsSync(globalPath);
+    const bundledPath = path34.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path34.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path34.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs31.existsSync(bundledPath) || fs31.existsSync(projectPath) || fs31.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -22264,13 +22012,13 @@ var SkillLoader = class _SkillLoader {
 };
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
-import fs32 from "fs";
-import path35 from "path";
+import fs33 from "fs";
+import path36 from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/app/agent/utils/blumamd.ts
-import fs31 from "fs";
-import path34 from "path";
+import fs32 from "fs";
+import path35 from "path";
 import os21 from "os";
 import { execSync } from "child_process";
 var MEMORY_INSTRUCTION_PROMPT = "Instru\xE7\xF5es de mem\xF3ria do BluMa (BLUMA.md) est\xE3o abaixo. Siga estas instru\xE7\xF5es exatamente como escritas. Estas instru\xE7\xF5es OVERRIDE qualquer comportamento padr\xE3o.";
@@ -22400,12 +22148,12 @@ var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 function expandIncludePath(includePath, baseDir) {
   const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
   if (cleanPath.startsWith("~")) {
-    return path34.join(os21.homedir(), cleanPath.slice(1));
+    return path35.join(os21.homedir(), cleanPath.slice(1));
   }
-  if (path34.isAbsolute(cleanPath)) {
+  if (path35.isAbsolute(cleanPath)) {
     return cleanPath;
   }
-  return path34.resolve(baseDir, cleanPath);
+  return path35.resolve(baseDir, cleanPath);
 }
 function processIncludes(content, baseDir, processedFiles) {
   const lines = content.split("\n");
@@ -22414,20 +22162,20 @@ function processIncludes(content, baseDir, processedFiles) {
     const includeMatch = line.match(/^@\s*([^\s]+)/);
     if (includeMatch) {
       const includePath = expandIncludePath(includeMatch[1], baseDir);
-      const normalizedPath = path34.normalize(includePath);
+      const normalizedPath = path35.normalize(includePath);
       if (processedFiles.has(normalizedPath)) {
         result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
         continue;
       }
-      const ext = path34.extname(includePath).toLowerCase();
+      const ext = path35.extname(includePath).toLowerCase();
       if (!TEXT_FILE_EXTENSIONS.has(ext)) {
         result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
         continue;
       }
       try {
-        const includedContent = fs31.readFileSync(includePath, "utf-8");
+        const includedContent = fs32.readFileSync(includePath, "utf-8");
         processedFiles.add(normalizedPath);
-        const processedContent = processIncludes(includedContent, path34.dirname(includePath), processedFiles);
+        const processedContent = processIncludes(includedContent, path35.dirname(includePath), processedFiles);
         result.push(`
 <!-- BEGIN INCLUDE ${includeMatch[1]} -->
 `);
@@ -22473,9 +22221,9 @@ function parseFrontmatterPaths(paths2) {
 }
 function readMemoryFile(filePath, type, includeBasePath) {
   try {
-    const rawContent = fs31.readFileSync(filePath, "utf-8");
-    const baseDir = includeBasePath || path34.dirname(filePath);
-    const processedFiles = /* @__PURE__ */ new Set([path34.normalize(filePath)]);
+    const rawContent = fs32.readFileSync(filePath, "utf-8");
+    const baseDir = includeBasePath || path35.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path35.normalize(filePath)]);
     const { frontmatter, content: withoutFrontmatter } = parseFrontmatter(rawContent);
     const globs = parseFrontmatterPaths(frontmatter.paths);
     const processedContent = processIncludes(withoutFrontmatter, baseDir, processedFiles);
@@ -22497,15 +22245,15 @@ function readMemoryFile(filePath, type, includeBasePath) {
 }
 function findGitRoot(startDir) {
   let current = startDir;
-  while (current !== path34.dirname(current)) {
-    const gitPath = path34.join(current, ".git");
+  while (current !== path35.dirname(current)) {
+    const gitPath = path35.join(current, ".git");
     try {
-      if (fs31.existsSync(gitPath)) {
+      if (fs32.existsSync(gitPath)) {
         return current;
       }
     } catch {
     }
-    current = path34.dirname(current);
+    current = path35.dirname(current);
   }
   return null;
 }
@@ -22530,17 +22278,17 @@ function getGitUserInfo(cwd2) {
 }
 function processRulesDirectory(rulesDir, type, processedPaths, conditionalRule = false) {
   const result = [];
-  if (!fs31.existsSync(rulesDir)) {
+  if (!fs32.existsSync(rulesDir)) {
     return result;
   }
   try {
-    const entries = fs31.readdirSync(rulesDir, { withFileTypes: true });
+    const entries = fs32.readdirSync(rulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path34.join(rulesDir, entry.name);
+      const entryPath = path35.join(rulesDir, entry.name);
       if (entry.isDirectory()) {
         result.push(...processRulesDirectory(entryPath, type, processedPaths, conditionalRule));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const normalizedPath = path34.normalize(entryPath);
+        const normalizedPath = path35.normalize(entryPath);
         if (processedPaths.has(normalizedPath)) {
           continue;
         }
@@ -22576,13 +22324,13 @@ function loadManagedMemory() {
 function loadUserMemory() {
   const files = [];
   const homeDir = os21.homedir();
-  const userBlumaDir = path34.join(homeDir, ".bluma");
-  const userBlumaMd = path34.join(userBlumaDir, "BLUMA.md");
+  const userBlumaDir = path35.join(homeDir, ".bluma");
+  const userBlumaMd = path35.join(userBlumaDir, "BLUMA.md");
   const userFile = readMemoryFile(userBlumaMd, "User");
   if (userFile && userFile.content.trim()) {
     files.push(userFile);
   }
-  const userRulesDir = path34.join(userBlumaDir, "rules");
+  const userRulesDir = path35.join(userBlumaDir, "rules");
   const processedPaths = /* @__PURE__ */ new Set();
   files.push(...processRulesDirectory(userRulesDir, "User", processedPaths, false));
   return files;
@@ -22594,10 +22342,10 @@ function loadProjectMemory(cwd2) {
   let currentDir = cwd2;
   const MAX_TRAVERSAL_DEPTH = 20;
   let depth = 0;
-  const normalizedGitRoot = path34.resolve(gitRoot);
-  while (currentDir !== path34.dirname(currentDir) && path34.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
+  const normalizedGitRoot = path35.resolve(gitRoot);
+  while (currentDir !== path35.dirname(currentDir) && path35.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
     dirs.push(currentDir);
-    currentDir = path34.dirname(currentDir);
+    currentDir = path35.dirname(currentDir);
     depth++;
   }
   if (!dirs.includes(gitRoot)) {
@@ -22605,7 +22353,7 @@ function loadProjectMemory(cwd2) {
   }
   const processedPaths = /* @__PURE__ */ new Set();
   for (const dir of dirs.reverse()) {
-    const projectBlumaMd = path34.join(dir, "BLUMA.md");
+    const projectBlumaMd = path35.join(dir, "BLUMA.md");
     if (!processedPaths.has(projectBlumaMd)) {
       processedPaths.add(projectBlumaMd);
       const projectFile = readMemoryFile(projectBlumaMd, "Project");
@@ -22613,7 +22361,7 @@ function loadProjectMemory(cwd2) {
         files.push(projectFile);
       }
     }
-    const blumaDirBlumaMd = path34.join(dir, ".bluma", "BLUMA.md");
+    const blumaDirBlumaMd = path35.join(dir, ".bluma", "BLUMA.md");
     if (!processedPaths.has(blumaDirBlumaMd)) {
       processedPaths.add(blumaDirBlumaMd);
       const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "Project");
@@ -22621,10 +22369,10 @@ function loadProjectMemory(cwd2) {
         files.push(blumaDirFile);
       }
     }
-    const rulesDir = path34.join(dir, ".bluma", "rules");
+    const rulesDir = path35.join(dir, ".bluma", "rules");
     files.push(...processRulesDirectory(rulesDir, "Project", processedPaths, false));
   }
-  const localBlumaMd = path34.join(cwd2, "BLUMA.local.md");
+  const localBlumaMd = path35.join(cwd2, "BLUMA.local.md");
   if (!processedPaths.has(localBlumaMd)) {
     processedPaths.add(localBlumaMd);
     const localFile = readMemoryFile(localBlumaMd, "Local");
@@ -22710,10 +22458,10 @@ var LIMITS = {
 };
 function safeReadFile(filePath, maxChars) {
   try {
-    if (!fs32.existsSync(filePath)) return null;
-    const st = fs32.statSync(filePath);
+    if (!fs33.existsSync(filePath)) return null;
+    const st = fs33.statSync(filePath);
     if (!st.isFile()) return null;
-    const raw = fs32.readFileSync(filePath, "utf8");
+    const raw = fs33.readFileSync(filePath, "utf8");
     if (raw.includes("\0")) return null;
     if (raw.length <= maxChars) return raw;
     return `${raw.slice(0, maxChars)}
@@ -22725,7 +22473,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd2) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path35.join(cwd2, name), LIMITS.readme);
+    const c = safeReadFile(path36.join(cwd2, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -22733,14 +22481,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd2) {
   const paths2 = [
-    path35.join(cwd2, "BluMa.md"),
-    path35.join(cwd2, "BLUMA.md"),
-    path35.join(cwd2, ".bluma", "BluMa.md")
+    path36.join(cwd2, "BluMa.md"),
+    path36.join(cwd2, "BLUMA.md"),
+    path36.join(cwd2, ".bluma", "BluMa.md")
   ];
   for (const p of paths2) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path35.relative(cwd2, p) || p;
+      const rel = path36.relative(cwd2, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -22748,10 +22496,10 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd2) {
-  const p = path35.join(cwd2, "package.json");
+  const p = path36.join(cwd2, "package.json");
   try {
-    if (!fs32.existsSync(p)) return null;
-    const pkg = JSON.parse(fs32.readFileSync(p, "utf8"));
+    if (!fs33.existsSync(p)) return null;
+    const pkg = JSON.parse(fs33.readFileSync(p, "utf8"));
     const scripts = pkg.scripts;
     let scriptKeys = "";
     if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
@@ -22784,7 +22532,7 @@ function summarizePackageJson(cwd2) {
 }
 function topLevelListing(cwd2) {
   try {
-    const names = fs32.readdirSync(cwd2, { withFileTypes: true });
+    const names = fs33.readdirSync(cwd2, { withFileTypes: true });
     const sorted = [...names].sort((a, b) => a.name.localeCompare(b.name));
     const limited = sorted.slice(0, LIMITS.topDirEntries);
     const lines = limited.map((d) => `${d.name}${d.isDirectory() ? "/" : ""}`);
@@ -22842,7 +22590,7 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path35.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path36.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -22860,15 +22608,15 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path35.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path36.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path35.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path36.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path35.join(cwd2, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path36.join(cwd2, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -22904,14 +22652,14 @@ function buildWorkspaceSnapshot(cwd2) {
   } else {
     parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
   }
-  const tsconfig = safeReadFile(path35.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
+  const tsconfig = safeReadFile(path36.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
   if (tsconfig) {
     parts.push("### tsconfig.json (excerpt)\n```json");
     parts.push(tsconfig);
     parts.push("```\n");
   }
   for (const name of ["Dockerfile", "dockerfile", "Dockerfile.prod", "Dockerfile.dev"]) {
-    const df = safeReadFile(path35.join(cwd2, name), LIMITS.dockerfile);
+    const df = safeReadFile(path36.join(cwd2, name), LIMITS.dockerfile);
     if (df) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22921,7 +22669,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const dc = safeReadFile(path35.join(cwd2, name), LIMITS.dockerfile);
+    const dc = safeReadFile(path36.join(cwd2, name), LIMITS.dockerfile);
     if (dc) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22936,12 +22684,12 @@ function buildWorkspaceSnapshot(cwd2) {
     ".circleci/config.yml",
     "Jenkinsfile"
   ]) {
-    const ciFile = path35.join(cwd2, ciPath);
-    if (fs32.existsSync(ciFile)) {
-      const st = fs32.statSync(ciFile);
+    const ciFile = path36.join(cwd2, ciPath);
+    if (fs33.existsSync(ciFile)) {
+      const st = fs33.statSync(ciFile);
       if (st.isDirectory()) {
         try {
-          const wfFiles = fs32.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+          const wfFiles = fs33.readdirSync(ciFile).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
           if (wfFiles.length > 0) {
             parts.push(`### GitHub Actions workflows
 \`${wfFiles.join("`, `")}\`
@@ -22952,7 +22700,7 @@ function buildWorkspaceSnapshot(cwd2) {
       } else {
         const ci = safeReadFile(ciFile, LIMITS.ciConfig);
         if (ci) {
-          parts.push(`### CI config (${path35.basename(ciPath)})
+          parts.push(`### CI config (${path36.basename(ciPath)})
 `);
           parts.push(ci);
           parts.push("\n");
@@ -22961,8 +22709,8 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const depFile of ["requirements.txt", "Pipfile", "poetry.lock", "Gemfile", "go.sum", "Cargo.lock"]) {
-    const depPath = path35.join(cwd2, depFile);
-    if (fs32.existsSync(depPath)) {
+    const depPath = path36.join(cwd2, depFile);
+    if (fs33.existsSync(depPath)) {
       const depContent = safeReadFile(depPath, 1500);
       if (depContent) {
         parts.push(`### ${depFile} (top entries)
@@ -22975,10 +22723,10 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
-    const envPath = path35.join(cwd2, envFile);
-    if (fs32.existsSync(envPath)) {
+    const envPath = path36.join(cwd2, envFile);
+    if (fs33.existsSync(envPath)) {
       try {
-        const raw = fs32.readFileSync(envPath, "utf-8");
+        const raw = fs33.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();
@@ -23001,15 +22749,15 @@ init_runtime_config();
 
 // src/app/agent/runtime/plugin_registry.ts
 init_sandbox_policy();
-import fs33 from "fs";
+import fs34 from "fs";
 import os22 from "os";
-import path36 from "path";
+import path37 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path36.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path37.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path36.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
+  return path37.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -23018,11 +22766,11 @@ function getPluginDirs() {
   };
 }
 function readManifest(manifestPath, fallbackName) {
-  if (!fs33.existsSync(manifestPath)) {
+  if (!fs34.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs33.readFileSync(manifestPath, "utf-8"));
+    const parsed = JSON.parse(fs34.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,
@@ -23035,22 +22783,22 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path36.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path36.join(pluginDir, "plugin.json")
+    path37.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path37.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
-    if (fs33.existsSync(candidate)) {
+    if (fs34.existsSync(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 function listFromDir(baseDir, source) {
-  if (!fs33.existsSync(baseDir)) {
+  if (!fs34.existsSync(baseDir)) {
     return [];
   }
-  return fs33.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path36.join(baseDir, entry.name);
+  return fs34.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+    const pluginDir = path37.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -23495,8 +23243,8 @@ function buildModelInfoSection(modelId) {
 
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
-import fs34 from "fs";
-import path37 from "path";
+import fs35 from "fs";
+import path38 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -23507,7 +23255,7 @@ var cache3 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path37.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path38.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -23526,8 +23274,8 @@ function ensureLoaded2() {
     return cache3;
   }
   try {
-    if (fs34.existsSync(statePath)) {
-      const parsed = JSON.parse(fs34.readFileSync(statePath, "utf-8"));
+    if (fs35.existsSync(statePath)) {
+      const parsed = JSON.parse(fs35.readFileSync(statePath, "utf-8"));
       cache3 = {
         enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_STATE.enabled,
         maxEvents: typeof parsed.maxEvents === "number" && Number.isFinite(parsed.maxEvents) && parsed.maxEvents > 0 ? Math.floor(parsed.maxEvents) : DEFAULT_STATE.maxEvents,
@@ -23553,9 +23301,9 @@ function ensureLoaded2() {
 }
 function persist2(state2) {
   const statePath = getStatePath();
-  fs34.mkdirSync(path37.dirname(statePath), { recursive: true });
+  fs35.mkdirSync(path38.dirname(statePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs34.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
+  fs35.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
   cache3 = state2;
   cachePath2 = statePath;
 }
@@ -23820,12 +23568,12 @@ init_session_memory_paths();
 import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 async function loadSessionMemoryForPrompt(sessionId, cwd2 = process.cwd()) {
   if (!sessionId?.trim()) return "";
-  const path57 = getSessionMemoryPath(sessionId, cwd2);
+  const path58 = getSessionMemoryPath(sessionId, cwd2);
   try {
-    const content = await readFile3(path57, "utf-8");
+    const content = await readFile3(path58, "utf-8");
     if (!content.trim()) return "";
     return `<session_memory>
-Notes for this conversation (${path57}):
+Notes for this conversation (${path58}):
 
 ${content.trim()}
 </session_memory>`;
@@ -23835,11 +23583,11 @@ ${content.trim()}
 }
 async function initSessionMemoryFile(sessionId, cwd2 = process.cwd()) {
   await ensureSessionMemoryDir(sessionId, cwd2);
-  const path57 = getSessionMemoryPath(sessionId, cwd2);
+  const path58 = getSessionMemoryPath(sessionId, cwd2);
   try {
-    await readFile3(path57, "utf-8");
+    await readFile3(path58, "utf-8");
   } catch {
-    await writeFile2(path57, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
+    await writeFile2(path58, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
 `, "utf-8");
   }
 }
@@ -23878,8 +23626,8 @@ The orchestrator configures these \u2014 **use the values already set**. Do not
 
 ## Flow A \u2014 New app (no \`factorai.sh.json\` yet)
 
-1. \`factorai.sh.create_next_app({ name, template: "full" })\` \u2014 prefer **full** for deploy (App Router + \`app/\` + shadcn base). Minimal also includes \`app/\` but full is safer for UI tasks.
-2. Customize with \`edit_tool\` / \`file_write\` / \`shell_command\` in the project directory (e.g. \`./{name}/app/page.tsx\`).
+1. \`factorai.sh.create_next_app({ name })\` \u2014 scaffold completo (App Router + \`components/ui/*\` factorai.sh). **L\xEA o campo \`agentGuide\` do resultado** (ou \`DESIGN.md\` na raiz) antes de editar UI. A home j\xE1 \xE9 uma landing escura polida (hero + cards); personaliza \`app/page.tsx\` para o produto (ver Refero Styles para refer\xEAncia visual).
+2. Customize with \`edit_tool\` / \`file_write\` / \`shell_command\` usando \`@/components/ui/*\` e classes sem\xE2nticas (\`bg-background\`, \`text-muted-foreground\`, etc.).
 3. Optional: \`npx tsc --noEmit\` to catch TS errors \u2014 **avoid** \`npm run build\` before deploy (creates \`.next/\` and inflates the ZIP).
 4. \`factorai.sh.deploy_app({ projectDir: "./{name}", name })\` \u2014 tool excludes \`node_modules\`, \`.next\`, \`.env*\` automatically. **Never** manual \`zip\` including \`node_modules\` or \`.next\`.
 5. Persist returned IDs into \`factorai.sh.json\` (tool does this when possible). Report live URL in \`message(result)\` via \`factor-sh-url-app\` (from manifest \`appUrl\`, absolute URL \u2014 prefix with \`SEVERINO_URL\` only when manifest has a path).
@@ -23972,17 +23720,17 @@ function getGitBranch(dir) {
   }
 }
 function getPackageManager(dir) {
-  if (fs35.existsSync(path38.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs35.existsSync(path38.join(dir, "yarn.lock"))) return "yarn";
-  if (fs35.existsSync(path38.join(dir, "bun.lockb"))) return "bun";
-  if (fs35.existsSync(path38.join(dir, "package-lock.json"))) return "npm";
+  if (fs36.existsSync(path39.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs36.existsSync(path39.join(dir, "yarn.lock"))) return "yarn";
+  if (fs36.existsSync(path39.join(dir, "bun.lockb"))) return "bun";
+  if (fs36.existsSync(path39.join(dir, "package-lock.json"))) return "npm";
   return "unknown";
 }
 function getProjectType(dir) {
   try {
-    const files = fs35.readdirSync(dir);
+    const files = fs36.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs35.readFileSync(path38.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs36.readFileSync(path39.join(dir, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.next) return "Next.js";
       if (deps.react) return "React";
@@ -24002,9 +23750,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path38.join(dir, "package.json");
-    if (fs35.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path39.join(dir, "package.json");
+    if (fs36.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -24013,7 +23761,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs35.existsSync(path38.join(dir, "pytest.ini")) || fs35.existsSync(path38.join(dir, "conftest.py"))) return "pytest";
+    if (fs36.existsSync(path39.join(dir, "pytest.ini")) || fs36.existsSync(path39.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -24021,9 +23769,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path38.join(dir, "package.json");
-    if (fs35.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path39.join(dir, "package.json");
+    if (fs36.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return "npm test";
       if (pkg.scripts?.["test:unit"]) return "npm run test:unit";
     }
@@ -24038,8 +23786,8 @@ function getTestCommand(dir) {
 }
 function isGitRepo(dir) {
   try {
-    const p = path38.join(dir, ".git");
-    return fs35.existsSync(p) && fs35.lstatSync(p).isDirectory();
+    const p = path39.join(dir, ".git");
+    return fs36.existsSync(p) && fs36.lstatSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -25472,10 +25220,10 @@ var LLMService = class {
 };
 
 // src/app/agent/utils/user_message_images.ts
-import fs36 from "fs";
+import fs37 from "fs";
 import os25 from "os";
-import path39 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import path40 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 var IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
 var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
 var MAX_IMAGES = 6;
@@ -25490,22 +25238,22 @@ var MIME = {
 function expandUserPath(p) {
   const t = p.trim();
   if (t.startsWith("~")) {
-    return path39.join(os25.homedir(), t.slice(1).replace(/^\//, ""));
+    return path40.join(os25.homedir(), t.slice(1).replace(/^\//, ""));
   }
   return t;
 }
 function isPathAllowed(absResolved, cwd2) {
-  const resolved = path39.normalize(path39.resolve(absResolved));
-  const cwdR = path39.normalize(path39.resolve(cwd2));
-  const homeR = path39.normalize(path39.resolve(os25.homedir()));
-  const tmpR = path39.normalize(path39.resolve(os25.tmpdir()));
-  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path39.sep);
-  const underHome = resolved === homeR || resolved.startsWith(homeR + path39.sep);
-  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path39.sep);
+  const resolved = path40.normalize(path40.resolve(absResolved));
+  const cwdR = path40.normalize(path40.resolve(cwd2));
+  const homeR = path40.normalize(path40.resolve(os25.homedir()));
+  const tmpR = path40.normalize(path40.resolve(os25.tmpdir()));
+  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path40.sep);
+  const underHome = resolved === homeR || resolved.startsWith(homeR + path40.sep);
+  const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path40.sep);
   return underCwd || underHome || underTmp;
 }
 function mimeFor(abs) {
-  const ext = path39.extname(abs).toLowerCase();
+  const ext = path40.extname(abs).toLowerCase();
   return MIME[ext] || "application/octet-stream";
 }
 var IMAGE_EXT_SRC = String.raw`(?:png|jpe?g|gif|webp|bmp)`;
@@ -25549,10 +25297,10 @@ function collectImagePathStrings(raw) {
 }
 function resolveImagePath(candidate, cwd2) {
   const expanded = expandUserPath(candidate);
-  const abs = path39.isAbsolute(expanded) ? path39.normalize(expanded) : path39.normalize(path39.resolve(cwd2, expanded));
+  const abs = path40.isAbsolute(expanded) ? path40.normalize(expanded) : path40.normalize(path40.resolve(cwd2, expanded));
   if (!isPathAllowed(abs, cwd2)) return null;
   try {
-    if (!fs36.existsSync(abs) || !fs36.statSync(abs).isFile()) return null;
+    if (!fs37.existsSync(abs) || !fs37.statSync(abs).isFile()) return null;
   } catch {
     return null;
   }
@@ -25564,7 +25312,7 @@ function trySingleLineFileUriOrBareImagePath(line, cwd2) {
   if (!s) return null;
   if (s.startsWith("file:")) {
     try {
-      s = fileURLToPath4(s);
+      s = fileURLToPath5(s);
     } catch {
       return null;
     }
@@ -25572,11 +25320,11 @@ function trySingleLineFileUriOrBareImagePath(line, cwd2) {
   if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
     s = s.slice(1, -1).trim();
   }
-  if (!IMAGE_EXT.test(path39.extname(s))) return null;
+  if (!IMAGE_EXT.test(path40.extname(s))) return null;
   const abs = resolveImagePath(s, cwd2);
   if (!abs) return null;
   try {
-    const st = fs36.statSync(abs);
+    const st = fs37.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -25611,7 +25359,7 @@ function tryPasteChunkAsSingleImagePath(chunk, cwd2) {
     return null;
   }
   try {
-    const st = fs36.statSync(abs);
+    const st = fs37.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -25640,7 +25388,7 @@ function buildUserMessageContent(raw, cwd2) {
     const abs = resolveImagePath(c, cwd2);
     if (!abs) continue;
     try {
-      const st = fs36.statSync(abs);
+      const st = fs37.statSync(abs);
       if (st.size > MAX_IMAGE_BYTES) continue;
     } catch {
       continue;
@@ -25657,7 +25405,7 @@ function buildUserMessageContent(raw, cwd2) {
   }
   const parts = [{ type: "text", text: textPart }];
   for (const abs of resolvedAbs) {
-    const buf = fs36.readFileSync(abs);
+    const buf = fs37.readFileSync(abs);
     const b64 = buf.toString("base64");
     const mime = mimeFor(abs);
     parts.push({
@@ -25675,7 +25423,7 @@ function buildUserMessageContent(raw, cwd2) {
 init_sandbox_policy();
 init_runtime_config();
 init_permission_rules();
-import path40 from "path";
+import path41 from "path";
 var LOCAL_EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["edit_tool", "file_write", "notebook_edit"]);
 function getToolPermissionLayer(metadata) {
   if (metadata.riskLevel === "safe") return "read";
@@ -25690,11 +25438,11 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (!filePath) {
     return { allowed: false, reason: "No file path provided for permission check." };
   }
-  const resolvedPath = path40.resolve(filePath);
+  const resolvedPath = path41.resolve(filePath);
   if (!isPathInsideWorkspace(resolvedPath, policy)) {
     return { allowed: false, reason: `File path "${filePath}" is outside workspace root.` };
   }
-  const relativePath = path40.relative(policy.workspaceRoot, resolvedPath);
+  const relativePath = path41.relative(policy.workspaceRoot, resolvedPath);
   const toolPattern = `${toolName}(${relativePath})`;
   const ruleDecision = permissionRulesEngine.checkPermission(toolPattern, { filepath: filePath });
   if (ruleDecision === "deny") {
@@ -25703,7 +25451,7 @@ function checkFilePermissionRules(toolName, filePath, policy) {
   if (ruleDecision === "allow") {
     return { allowed: true, reason: `File "${filePath}" allowed by permission rules.` };
   }
-  const dirPath = path40.dirname(relativePath);
+  const dirPath = path41.dirname(relativePath);
   const dirPattern = `${toolName}(${dirPath}/**)`;
   const dirRuleDecision = permissionRulesEngine.checkPermission(dirPattern, { filepath: filePath });
   if (dirRuleDecision === "allow") {
@@ -25920,11 +25668,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryConsolidate.ts
-import * as fs37 from "fs";
-import * as path41 from "path";
+import * as fs38 from "fs";
+import * as path42 from "path";
 import os26 from "os";
 function memoryPath2() {
-  return path41.join(process.env.HOME || os26.homedir(), ".bluma", "coding_memory.json");
+  return path42.join(process.env.HOME || os26.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -25934,18 +25682,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath2();
-  if (!fs37.existsSync(p)) {
+  if (!fs38.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs37.copyFileSync(p, bak);
+    fs38.copyFileSync(p, bak);
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `backup failed: ${e.message}` };
   }
   let data;
   try {
-    data = JSON.parse(fs37.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs38.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -25980,7 +25728,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs37.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs38.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -26486,18 +26234,18 @@ var BluMaToolRunner = class {
 
 // src/app/agent/session_manager/session_archive.ts
 init_bluma_app_dir();
-import path42 from "path";
-import { promises as fs38 } from "fs";
+import path43 from "path";
+import { promises as fs39 } from "fs";
 async function archivePrunedConversationMessages(sessionId, messages) {
   if (!sessionId || messages.length === 0) {
     return null;
   }
   const appDir = getPreferredAppDir();
-  const dir = path42.join(appDir, "sessions", "archive", sessionId);
-  await fs38.mkdir(dir, { recursive: true });
-  const archiveFile = path42.join(dir, `${Date.now()}.jsonl`);
+  const dir = path43.join(appDir, "sessions", "archive", sessionId);
+  await fs39.mkdir(dir, { recursive: true });
+  const archiveFile = path43.join(dir, `${Date.now()}.jsonl`);
   const lines = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  await fs38.appendFile(archiveFile, lines, "utf-8");
+  await fs39.appendFile(archiveFile, lines, "utf-8");
   return archiveFile;
 }
 
@@ -27358,7 +27106,7 @@ Update existing files instead of duplicating.` : "";
 
 // src/app/agent/memory/memory_tool_policy.ts
 init_paths();
-import path43 from "path";
+import path44 from "path";
 var MEMORY_READ_TOOLS = /* @__PURE__ */ new Set([
   "read_file_lines",
   "grep_search",
@@ -27385,7 +27133,7 @@ function isReadOnlyShellCommand(command) {
   return READ_ONLY_SHELL.test(trimmed);
 }
 function createAutoMemToolGate(memoryDir) {
-  const memRoot = memoryDir.endsWith(path43.sep) ? memoryDir : memoryDir + path43.sep;
+  const memRoot = memoryDir.endsWith(path44.sep) ? memoryDir : memoryDir + path44.sep;
   return (toolName, args) => {
     if (MEMORY_READ_TOOLS.has(toolName)) {
       return { allowed: true };
@@ -27398,7 +27146,7 @@ function createAutoMemToolGate(memoryDir) {
     }
     if (MEMORY_WRITE_TOOLS.has(toolName)) {
       const fp = extractFilePath(args);
-      if (fp && isAutoMemPath(path43.resolve(fp))) {
+      if (fp && isAutoMemPath(path44.resolve(fp))) {
         return { allowed: true };
       }
       return { allowed: false, reason: `Writes must stay under ${memRoot}` };
@@ -27407,18 +27155,18 @@ function createAutoMemToolGate(memoryDir) {
   };
 }
 function createSessionMemoryToolGate(sessionMemoryPath) {
-  const resolvedTarget = path43.resolve(sessionMemoryPath);
+  const resolvedTarget = path44.resolve(sessionMemoryPath);
   return (toolName, args) => {
     if (toolName === "read_file_lines") {
       const fp = extractFilePath(args);
-      if (fp && path43.resolve(fp) === resolvedTarget) {
+      if (fp && path44.resolve(fp) === resolvedTarget) {
         return { allowed: true };
       }
       return { allowed: false, reason: "Session memory subagent may only read the session summary file" };
     }
     if (toolName === "edit_tool") {
       const fp = extractFilePath(args);
-      if (fp && path43.resolve(fp) === resolvedTarget) {
+      if (fp && path44.resolve(fp) === resolvedTarget) {
         return { allowed: true };
       }
       return { allowed: false, reason: "Session memory subagent may only edit the session summary file" };
@@ -27445,7 +27193,7 @@ function hasAutoMemWritesSinceHistory(history, sinceIndex) {
         continue;
       }
       const fp = extractFilePath(args);
-      if (fp && isAutoMemPath(path43.resolve(fp))) {
+      if (fp && isAutoMemPath(path44.resolve(fp))) {
         return true;
       }
     }
@@ -27913,13 +27661,13 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     try {
       const sessionData = {
-        session_id: path44.basename(this.sessionFile, ".json"),
+        session_id: path45.basename(this.sessionFile, ".json"),
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: this.history,
         last_updated: (/* @__PURE__ */ new Date()).toISOString(),
         ...this.compressor.getSnapshot()
       };
-      fs39.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      fs40.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
     } catch (error) {
       console.error("[Bluma] Failed to persist session synchronously:", error);
     }
@@ -28125,7 +27873,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path44.basename(toolArgs.file_path);
+      const filename = path45.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}`;
@@ -28859,16 +28607,16 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 }
 
 // src/app/agent/core/memory/session_memory.ts
-import fs40 from "fs";
+import fs41 from "fs";
 import os29 from "os";
-import path45 from "path";
+import path46 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path45.join(os29.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path46.join(os29.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -28925,15 +28673,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);
-    fs40.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
+    fs41.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
   }
   /**
    * Load memories from disk
    */
   async loadMemories() {
     try {
-      if (!fs40.existsSync(this.memoryFile)) return [];
-      const data = fs40.readFileSync(this.memoryFile, "utf-8");
+      if (!fs41.existsSync(this.memoryFile)) return [];
+      const data = fs41.readFileSync(this.memoryFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return [];
@@ -29477,14 +29225,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path57, handler) {
-    this.routeHandlers.set(path57, handler);
+  registerRoute(path58, handler) {
+    this.routeHandlers.set(path58, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext, options } = payload;
-    for (const [path57, handler] of this.routeHandlers) {
-      if (inputText === path57 || inputText.startsWith(`${path57} `)) {
+    for (const [path58, handler] of this.routeHandlers) {
+      if (inputText === path58 || inputText.startsWith(`${path58} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -29493,13 +29241,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path46 from "path";
+import path47 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 = path46.resolve(p.root, entry);
+    const abs = path47.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -29520,7 +29268,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path47.join(os30.homedir(), ".bluma", ".env");
+var globalEnvPath = path48.join(os30.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -31376,10 +31124,10 @@ function resolveToolPayload(result) {
 
 // src/app/ui/components/FilePathLink.tsx
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import path49 from "node:path";
+import path50 from "node:path";
 
 // src/app/ui/utils/pathDisplay.ts
-import path48 from "node:path";
+import path49 from "node:path";
 import os31 from "node:os";
 function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
   let s = String(pathInput ?? "").trim();
@@ -31387,17 +31135,17 @@ function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
     s = s.replace(/[/\\]+$/, "");
   }
   if (!s) return "";
-  const abs = path48.isAbsolute(s) ? path48.normalize(s) : path48.resolve(cwd2, s);
-  const resolvedCwd = path48.resolve(cwd2);
-  const rel = path48.relative(resolvedCwd, abs);
-  if (rel === "" || !rel.startsWith("..") && !path48.isAbsolute(rel)) {
+  const abs = path49.isAbsolute(s) ? path49.normalize(s) : path49.resolve(cwd2, s);
+  const resolvedCwd = path49.resolve(cwd2);
+  const rel = path49.relative(resolvedCwd, abs);
+  if (rel === "" || !rel.startsWith("..") && !path49.isAbsolute(rel)) {
     return rel === "" ? "." : rel;
   }
-  const home = path48.normalize(os31.homedir());
-  if (abs === home || abs.startsWith(home + path48.sep)) {
+  const home = path49.normalize(os31.homedir());
+  if (abs === home || abs.startsWith(home + path49.sep)) {
     return "~" + abs.slice(home.length);
   }
-  return path48.basename(abs);
+  return path49.basename(abs);
 }
 
 // src/app/ui/components/FilePathLink.tsx
@@ -31407,7 +31155,7 @@ function FilePathLink({ filePath, children, cwd: cwd2 = process.cwd(), color })
   if (!raw) {
     return null;
   }
-  const abs = path49.isAbsolute(raw) ? path49.normalize(raw) : path49.resolve(cwd2, raw);
+  const abs = path50.isAbsolute(raw) ? path50.normalize(raw) : path50.resolve(cwd2, raw);
   const href = pathToFileURL3(abs).href;
   const label = formatPathForDisplay(abs, cwd2);
   const text = typeof children === "string" ? children : label;
@@ -33359,12 +33107,12 @@ function patchToUnifiedDiffText(filePath, patch) {
 }
 
 // src/app/ui/utils/readEditContext.ts
-import { promises as fs41 } from "fs";
+import { promises as fs42 } from "fs";
 var CHUNK_SIZE = 64 * 1024;
 var CONTEXT_LINES2 = 3;
 async function openForScan(filePath) {
   try {
-    return await fs41.open(filePath, "r");
+    return await fs42.open(filePath, "r");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
@@ -34042,13 +33790,13 @@ function EditToolDiffPanel({
   newString,
   replaceAll = false
 }) {
-  const path57 = filePath.trim() || "unknown file";
+  const path58 = filePath.trim() || "unknown file";
   const hasPreviewArgs = oldString !== void 0 && newString !== void 0;
   const hasDiffText = diffText && diffText.trim().length > 0;
   return /* @__PURE__ */ jsx43(Box_default, { flexDirection: "column", children: hasPreviewArgs ? /* @__PURE__ */ jsx43(Box_default, { marginTop: 0, children: /* @__PURE__ */ jsx43(
     FileEditToolDiff,
     {
-      filePath: path57,
+      filePath: path58,
       oldString,
       newString,
       replaceAll,
@@ -34086,7 +33834,7 @@ function renderToolUseMessage12({ args }) {
   return /* @__PURE__ */ jsx44(Text, { color: BLUMA_TERMINAL.blue, children: p });
 }
 function renderToolHeader12({ args }) {
-  const path57 = args?.file_path ?? ".";
+  const path58 = args?.file_path ?? ".";
   const oldText = typeof args?.old_string === "string" ? args.old_string : "";
   const newText = typeof args?.new_string === "string" ? args.new_string : "";
   const counts = countLineDiff(oldText, newText);
@@ -34096,7 +33844,7 @@ function renderToolHeader12({ args }) {
       action,
       /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
         " ",
-        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path57, color: BLUMA_TERMINAL.dim })
+        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path58, color: BLUMA_TERMINAL.dim })
       ] })
     ] }),
     /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
@@ -34488,11 +34236,11 @@ function userFacingName13() {
 }
 function renderToolUseMessage14({ args }) {
   const q = args?.query ? `"${args.query}"` : "...";
-  const path57 = args?.path || ".";
+  const path58 = args?.path || ".";
   return /* @__PURE__ */ jsxs30(Box_default, { flexDirection: "row", flexWrap: "wrap", alignItems: "flex-end", children: [
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.blue, children: q }),
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.dim, children: " " }),
-    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path57, color: BLUMA_TERMINAL.dim })
+    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path58, color: BLUMA_TERMINAL.dim })
   ] });
 }
 function renderToolHeader14({ args }) {
@@ -35014,7 +34762,7 @@ var loadSkillTool = createTool({
 });
 
 // src/app/agent/tools/FileWriteTool/UI.tsx
-import fs42 from "fs";
+import fs43 from "fs";
 import { diffLines as diffLines3 } from "diff";
 import { jsx as jsx54, jsxs as jsxs37 } from "react/jsx-runtime";
 function getFilePath(args) {
@@ -35029,7 +34777,7 @@ function getFilePath(args) {
 function readExistingFileText(filePath) {
   if (!filePath) return "";
   try {
-    return fs42.readFileSync(filePath, "utf-8");
+    return fs43.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -36345,7 +36093,7 @@ function renderToolUseMessage35({ args }) {
 function renderToolHeader35({ args }) {
   return /* @__PURE__ */ jsxs51(Box_default, { flexDirection: "row", gap: 1, alignItems: "flex-end", children: [
     /* @__PURE__ */ jsx68(Text, { bold: true, color: BLUMA_TERMINAL.m3OnSurface, children: "Create App" }),
-    /* @__PURE__ */ jsx68(Text, { color: BLUMA_TERMINAL.dim, children: args?.template ?? "full" })
+    /* @__PURE__ */ jsx68(Text, { color: BLUMA_TERMINAL.dim, children: "FactorAI scaffold" })
   ] });
 }
 function renderToolMessage34({
@@ -36370,11 +36118,20 @@ function renderToolResultMessage35(result) {
     ] });
   }
   return /* @__PURE__ */ jsxs51(Box_default, { flexDirection: "column", children: [
+    result.summary && /* @__PURE__ */ jsx68(Text, { color: BLUMA_TERMINAL.m3OnSurface, wrap: "wrap", children: result.summary }),
     result.projectPath && /* @__PURE__ */ jsxs51(Box_default, { flexDirection: "row", children: [
       /* @__PURE__ */ jsx68(Text, { color: BLUMA_TERMINAL.dim, children: "\u2514\u2500 " }),
       /* @__PURE__ */ jsx68(FilePathLink, { filePath: result.projectPath, color: BLUMA_TERMINAL.dim })
     ] }),
-    Array.isArray(result.filesCreated) && result.filesCreated.length > 0 && /* @__PURE__ */ jsxs51(Text, { color: BLUMA_TERMINAL.m3OnSurface, children: [
+    typeof result.uiComponentCount === "number" && /* @__PURE__ */ jsxs51(Text, { color: BLUMA_TERMINAL.dim, children: [
+      result.uiComponentCount,
+      " UI components \xB7 DESIGN.md written"
+    ] }),
+    result.designDocPath && /* @__PURE__ */ jsxs51(Box_default, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx68(Text, { color: BLUMA_TERMINAL.dim, children: "\u2514\u2500 " }),
+      /* @__PURE__ */ jsx68(FilePathLink, { filePath: result.designDocPath, color: BLUMA_TERMINAL.dim })
+    ] }),
+    Array.isArray(result.filesCreated) && result.filesCreated.length > 0 && /* @__PURE__ */ jsxs51(Text, { color: BLUMA_TERMINAL.dim, children: [
       result.filesCreated.length,
       " files created"
     ] }),
@@ -37959,8 +37716,8 @@ import {
 
 // src/app/ui/hooks/useAtCompletion.ts
 import { useEffect as useEffect11, useRef as useRef4, useState as useState13 } from "react";
-import fs43 from "fs";
-import path50 from "path";
+import fs44 from "fs";
+import path51 from "path";
 var MAX_RESULTS3 = 50;
 var DEFAULT_RECURSIVE_DEPTH = 2;
 function listPathSuggestions(baseDir, pattern) {
@@ -37968,7 +37725,7 @@ function listPathSuggestions(baseDir, pattern) {
   const patternEndsWithSlash = raw.endsWith("/");
   const relDir = raw.replace(/^\/+|\/+$/g, "");
   const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
-  const listDir = path50.resolve(baseDir, relDir || ".");
+  const listDir = path51.resolve(baseDir, relDir || ".");
   const results = [];
   const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
   const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
@@ -37985,7 +37742,7 @@ function listPathSuggestions(baseDir, pattern) {
   }
   function pushEntry(entryPath, label, isDir) {
     if (results.length >= MAX_RESULTS3) return;
-    const clean = label.split(path50.sep).join("/").replace(/[]+/g, "");
+    const clean = label.split(path51.sep).join("/").replace(/[]+/g, "");
     results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
   }
   try {
@@ -37994,11 +37751,11 @@ function listPathSuggestions(baseDir, pattern) {
       while (queue.length && results.length < MAX_RESULTS3) {
         const node = queue.shift();
         try {
-          const entries = fs43.readdirSync(node.dir, { withFileTypes: true });
+          const entries = fs44.readdirSync(node.dir, { withFileTypes: true });
           for (const entry of entries) {
             if (isIgnoredName(entry.name)) continue;
-            const entryAbs = path50.join(node.dir, entry.name);
-            const entryRel = node.rel ? path50.posix.join(node.rel, entry.name) : entry.name;
+            const entryAbs = path51.join(node.dir, entry.name);
+            const entryRel = node.rel ? path51.posix.join(node.rel, entry.name) : entry.name;
             if (entryRel.split("/").includes("node_modules")) continue;
             if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
             pushEntry(entryAbs, entryRel, entry.isDirectory());
@@ -38011,13 +37768,13 @@ function listPathSuggestions(baseDir, pattern) {
         }
       }
     } else {
-      const entries = fs43.readdirSync(listDir, { withFileTypes: true });
+      const entries = fs44.readdirSync(listDir, { withFileTypes: true });
       for (const entry of entries) {
         if (filterPrefix && !entry.name.startsWith(filterPrefix)) continue;
         if (isIgnoredName(entry.name)) continue;
         if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
-        const entryAbs = path50.join(listDir, entry.name);
-        const label = relDir ? path50.posix.join(relDir, entry.name) : entry.name;
+        const entryAbs = path51.join(listDir, entry.name);
+        const label = relDir ? path51.posix.join(relDir, entry.name) : entry.name;
         pushEntry(entryAbs, label, entry.isDirectory());
         if (results.length >= MAX_RESULTS3) break;
       }
@@ -38218,9 +37975,9 @@ var SlashSubmenuInlineComponent = ({ menu }) => {
 var SlashSubmenuInline = memo15(SlashSubmenuInlineComponent);
 
 // src/app/ui/utils/clipboardImage.ts
-import fs44 from "fs";
+import fs45 from "fs";
 import os32 from "os";
-import path51 from "path";
+import path52 from "path";
 import { spawn as spawn5, execFile as execFileCb, execSync as execSync4 } from "child_process";
 import { promisify as promisify2 } from "util";
 
@@ -38228,12 +37985,12 @@ import { promisify as promisify2 } from "util";
 import { existsSync as existsSync7 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { dirname as dirname4, join as join13 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { fileURLToPath as fileURLToPath6 } from "url";
 var __dirname;
 function getDirname() {
   if (!__dirname) {
     try {
-      __dirname = dirname4(fileURLToPath5(import.meta.url));
+      __dirname = dirname4(fileURLToPath6(import.meta.url));
     } catch {
       __dirname = process.cwd();
     }
@@ -38349,8 +38106,8 @@ function commandOnPath(cmd) {
 function unixClipboardHelperDirs() {
   const h = os32.homedir();
   return [
-    path51.join(h, ".local", "bin"),
-    path51.join(h, "bin"),
+    path52.join(h, ".local", "bin"),
+    path52.join(h, "bin"),
     "/usr/bin",
     "/usr/local/bin",
     "/bin",
@@ -38368,16 +38125,16 @@ function resolveHelperBinary(cmd) {
     return cmd;
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path51.join(dir, cmd);
+    const full = path52.join(dir, cmd);
     try {
-      fs44.accessSync(full, fs44.constants.X_OK);
+      fs45.accessSync(full, fs45.constants.X_OK);
       return full;
     } catch {
     }
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path51.join(dir, cmd);
-    if (fs44.existsSync(full)) {
+    const full = path52.join(dir, cmd);
+    if (fs45.existsSync(full)) {
       return full;
     }
   }
@@ -38418,17 +38175,17 @@ function writeBufferIfImage(baseDir, buf) {
   if (!ext) {
     return null;
   }
-  const out = path51.join(
+  const out = path52.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
-  fs44.writeFileSync(out, buf);
+  fs45.writeFileSync(out, buf);
   return out;
 }
 function unlinkQuiet(p) {
   try {
-    if (fs44.existsSync(p)) {
-      fs44.unlinkSync(p);
+    if (fs45.existsSync(p)) {
+      fs45.unlinkSync(p);
     }
   } catch {
   }
@@ -38445,25 +38202,25 @@ async function tryDarwinClipboardy(baseDir) {
       return null;
     }
     for (const src of tmpPaths) {
-      if (!src || !fs44.existsSync(src)) {
+      if (!src || !fs45.existsSync(src)) {
         continue;
       }
       let st;
       try {
-        st = fs44.statSync(src);
+        st = fs45.statSync(src);
       } catch {
         continue;
       }
       if (st.size < 80 || st.size > CLIPBOARD_MAX_BYTES) {
         continue;
       }
-      const ext = path51.extname(src).toLowerCase();
+      const ext = path52.extname(src).toLowerCase();
       const safeExt = ext && /^\.(png|jpe?g|gif|webp)$/i.test(ext) ? ext : ".png";
-      const out = path51.join(
+      const out = path52.join(
         baseDir,
         `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${safeExt}`
       );
-      fs44.copyFileSync(src, out);
+      fs45.copyFileSync(src, out);
       for (const p of tmpPaths) {
         unlinkQuiet(p);
       }
@@ -38477,14 +38234,14 @@ async function tryDarwinClipboardy(baseDir) {
   return null;
 }
 async function tryWindowsPowerShell(outFile) {
-  const ps = process.env.SystemRoot != null ? path51.join(
+  const ps = process.env.SystemRoot != null ? path52.join(
     process.env.SystemRoot,
     "System32",
     "WindowsPowerShell",
     "v1.0",
     "powershell.exe"
   ) : "powershell.exe";
-  if (!fs44.existsSync(ps)) {
+  if (!fs45.existsSync(ps)) {
     return false;
   }
   const script = "$ErrorActionPreference='Stop';Add-Type -AssemblyName System.Windows.Forms;Add-Type -AssemblyName System.Drawing;$img=[System.Windows.Forms.Clipboard]::GetImage();if($null -eq $img){exit 2};$img.Save($env:BLUMA_CLIP_OUT,[System.Drawing.Imaging.ImageFormat]::Png);exit 0";
@@ -38506,7 +38263,7 @@ async function tryWindowsPowerShell(outFile) {
     return false;
   }
   try {
-    const st = fs44.statSync(outFile);
+    const st = fs45.statSync(outFile);
     return st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES;
   } catch {
     return false;
@@ -38578,8 +38335,8 @@ function parseClipboardTextAsImagePath(raw) {
     s = s.slice(1, -1);
   }
   s = s.trim();
-  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path51.extname(s))) return null;
-  const abs = path51.isAbsolute(s) ? path51.normalize(s) : path51.resolve(process.cwd(), s);
+  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path52.extname(s))) return null;
+  const abs = path52.isAbsolute(s) ? path52.normalize(s) : path52.resolve(process.cwd(), s);
   return abs;
 }
 async function tryClipboardTextAsImageFile(baseDir) {
@@ -38593,19 +38350,19 @@ async function tryClipboardTextAsImageFile(baseDir) {
   const abs = parseClipboardTextAsImagePath(t);
   if (!abs) return null;
   try {
-    if (!fs44.existsSync(abs)) return null;
-    const st = fs44.statSync(abs);
+    if (!fs45.existsSync(abs)) return null;
+    const st = fs45.statSync(abs);
     if (!st.isFile() || st.size > CLIPBOARD_MAX_BYTES || st.size < 20) return null;
   } catch {
     return null;
   }
-  const ext = path51.extname(abs).toLowerCase();
-  const out = path51.join(
+  const ext = path52.extname(abs).toLowerCase();
+  const out = path52.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
   try {
-    fs44.copyFileSync(abs, out);
+    fs45.copyFileSync(abs, out);
     return out;
   } catch {
     return null;
@@ -38615,7 +38372,7 @@ async function tryLinuxShellPipelineSave(baseDir) {
   if (process.platform !== "linux" && process.platform !== "freebsd") {
     return null;
   }
-  const outPath = path51.join(
+  const outPath = path52.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`
   );
@@ -38637,11 +38394,11 @@ printf '%s' "$OUT"
       maxBuffer: 4096
     });
     const written = String(stdout ?? "").trim();
-    if (written !== outPath || !fs44.existsSync(outPath)) {
+    if (written !== outPath || !fs45.existsSync(outPath)) {
       unlinkQuiet(outPath);
       return null;
     }
-    const buf = fs44.readFileSync(outPath);
+    const buf = fs45.readFileSync(outPath);
     unlinkQuiet(outPath);
     return writeBufferIfImage(baseDir, buf);
   } catch {
@@ -38662,8 +38419,8 @@ async function tryNativeClipboardImage() {
   }
   try {
     const result = readClipboardImageNative();
-    if (fs44.existsSync(result.path)) {
-      const st = fs44.statSync(result.path);
+    if (fs45.existsSync(result.path)) {
+      const st = fs45.statSync(result.path);
       if (st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES) {
         return result.path;
       }
@@ -38673,8 +38430,8 @@ async function tryNativeClipboardImage() {
   return null;
 }
 async function readClipboardImageToTempFile() {
-  const baseDir = path51.join(os32.homedir(), ".cache", "bluma", "clipboard");
-  fs44.mkdirSync(baseDir, { recursive: true });
+  const baseDir = path52.join(os32.homedir(), ".cache", "bluma", "clipboard");
+  fs45.mkdirSync(baseDir, { recursive: true });
   const nativeResult = await tryNativeClipboardImage();
   if (nativeResult) {
     return nativeResult;
@@ -38692,7 +38449,7 @@ async function readClipboardImageToTempFile() {
     }
   }
   if (process.platform === "win32") {
-    const outFile = path51.join(
+    const outFile = path52.join(
       baseDir,
       `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`
     );
@@ -38733,7 +38490,7 @@ function expandLargePastePlaceholder(value, pending) {
 }
 
 // src/app/ui/components/InputPrompt.tsx
-import fs45 from "fs";
+import fs46 from "fs";
 import { Fragment as Fragment7, jsx as jsx79, jsxs as jsxs62 } from "react/jsx-runtime";
 var persistedInputState = { text: "", cursorPosition: 0 };
 var StaticCursor = () => /* @__PURE__ */ jsx79(Box_default, { flexDirection: "row", flexWrap: "nowrap", children: /* @__PURE__ */ jsx79(Text, { bold: true, color: BLUMA_TERMINAL.m3OnSurface, children: "\u2588 " }) });
@@ -38900,7 +38657,7 @@ var InputPrompt = memo16(({
           return;
         }
         if (routeText.startsWith("/")) {
-          const isFilePath = map.size > 0 && fs45.existsSync(routeText.split(/\s+/)[0]);
+          const isFilePath = map.size > 0 && fs46.existsSync(routeText.split(/\s+/)[0]);
           if (isFilePath) {
             uiEventBus.emit("user_overlay", {
               kind: "message",
@@ -41181,8 +40938,8 @@ var renderCode = () => {
 
 // src/app/agent/core/thread/thread_store.ts
 init_bluma_app_dir();
-import path52 from "path";
-import { promises as fs46 } from "fs";
+import path53 from "path";
+import { promises as fs47 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 var INDEX_VERSION = 1;
 var fileLocks2 = /* @__PURE__ */ new Map();
@@ -41207,9 +40964,9 @@ var ThreadStore = class {
   packageVersion;
   constructor() {
     const appDir = getPreferredAppDir();
-    this.threadsDir = path52.join(appDir, "threads");
-    this.archiveDir = path52.join(this.threadsDir, "archive");
-    this.indexPath = path52.join(this.threadsDir, "index.json");
+    this.threadsDir = path53.join(appDir, "threads");
+    this.archiveDir = path53.join(this.threadsDir, "archive");
+    this.indexPath = path53.join(this.threadsDir, "index.json");
     this.packageVersion = process.env.npm_package_version || "0.0.0";
   }
   // ==================== Inicialização ====================
@@ -41217,10 +40974,10 @@ var ThreadStore = class {
    * Inicializa o diretório de threads
    */
   async initialize() {
-    await fs46.mkdir(this.threadsDir, { recursive: true });
-    await fs46.mkdir(this.archiveDir, { recursive: true });
+    await fs47.mkdir(this.threadsDir, { recursive: true });
+    await fs47.mkdir(this.archiveDir, { recursive: true });
     try {
-      await fs46.access(this.indexPath);
+      await fs47.access(this.indexPath);
     } catch {
       await this.saveIndex({ version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
     }
@@ -41249,7 +41006,7 @@ var ThreadStore = class {
   async loadIndex() {
     return withFileLock2(this.indexPath, async () => {
       try {
-        const content = await fs46.readFile(this.indexPath, "utf-8");
+        const content = await fs47.readFile(this.indexPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return { version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
@@ -41260,8 +41017,8 @@ var ThreadStore = class {
     return withFileLock2(this.indexPath, async () => {
       index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
       const tempPath = `${this.indexPath}.${Date.now()}.tmp`;
-      await fs46.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
-      await fs46.rename(tempPath, this.indexPath);
+      await fs47.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
+      await fs47.rename(tempPath, this.indexPath);
     });
   }
   // ==================== Git Info ====================
@@ -41331,7 +41088,7 @@ var ThreadStore = class {
       messages: params.initialMessages || []
     };
     const historyPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs46.mkdir(path52.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path53.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -41386,7 +41143,7 @@ var ThreadStore = class {
       compressedSliceCount: source.history.compressedSliceCount
     };
     const historyPath = this.buildDatedThreadHistoryPath(newThreadId);
-    await fs46.mkdir(path52.dirname(historyPath), { recursive: true });
+    await fs47.mkdir(path53.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -41459,9 +41216,9 @@ var ThreadStore = class {
     const entry = index.threads[entryIndex];
     if (entry.status === "archived") return true;
     const oldPath = entry.historyPath || this.getLegacyHistoryPath(threadId);
-    const newPath = path52.join(this.archiveDir, `${threadId}.jsonl`);
+    const newPath = path53.join(this.archiveDir, `${threadId}.jsonl`);
     try {
-      await fs46.rename(oldPath, newPath);
+      await fs47.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -41482,11 +41239,11 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     if (entry.status === "active") return true;
-    const oldPath = path52.join(this.archiveDir, `${threadId}.jsonl`);
+    const oldPath = path53.join(this.archiveDir, `${threadId}.jsonl`);
     const newPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs46.mkdir(path52.dirname(newPath), { recursive: true });
+    await fs47.mkdir(path53.dirname(newPath), { recursive: true });
     try {
-      await fs46.rename(oldPath, newPath);
+      await fs47.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -41507,7 +41264,7 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     try {
-      await fs46.unlink(entry.historyPath);
+      await fs47.unlink(entry.historyPath);
     } catch {
     }
     index.threads.splice(entryIndex, 1);
@@ -41517,28 +41274,28 @@ var ThreadStore = class {
   }
   // ==================== Histórico ====================
   getLegacyHistoryPath(threadId) {
-    return path52.join(this.threadsDir, `${threadId}.jsonl`);
+    return path53.join(this.threadsDir, `${threadId}.jsonl`);
   }
   /** ~/.bluma/threads/YYYY/MM/DD/<threadId>.jsonl (data local de criação). */
   buildDatedThreadHistoryPath(threadId, at = /* @__PURE__ */ new Date()) {
     const y = String(at.getFullYear());
     const mo = String(at.getMonth() + 1).padStart(2, "0");
     const d = String(at.getDate()).padStart(2, "0");
-    return path52.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
+    return path53.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
   }
   async resolveHistoryPath(threadId) {
     const index = await this.loadIndex();
     const entry = index.threads.find((t) => t.threadId === threadId);
     if (entry?.historyPath) {
       try {
-        await fs46.access(entry.historyPath);
+        await fs47.access(entry.historyPath);
         return entry.historyPath;
       } catch {
       }
     }
     const legacy = this.getLegacyHistoryPath(threadId);
     try {
-      await fs46.access(legacy);
+      await fs47.access(legacy);
       return legacy;
     } catch {
       return entry?.historyPath ?? legacy;
@@ -41555,9 +41312,9 @@ var ThreadStore = class {
     for (const msg of history.messages) {
       lines.push(JSON.stringify({ type: "message", ...msg }));
     }
-    await fs46.mkdir(path52.dirname(historyPath), { recursive: true }).catch(() => {
+    await fs47.mkdir(path53.dirname(historyPath), { recursive: true }).catch(() => {
     });
-    await fs46.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs47.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
   }
   /**
    * Guarda o histórico de uma thread
@@ -41579,7 +41336,7 @@ var ThreadStore = class {
     ].filter((p, i, arr) => Boolean(p) && arr.indexOf(p) === i);
     for (const historyPath of pathsToTry) {
       try {
-        const content = await fs46.readFile(historyPath, "utf-8");
+        const content = await fs47.readFile(historyPath, "utf-8");
         const lines = content.split("\n").filter(Boolean);
         const history = {
           threadId,
@@ -41614,7 +41371,7 @@ var ThreadStore = class {
     const entry = index.threads.find((t) => t.threadId === threadId);
     if (!entry) throw new Error(`Thread not found: ${threadId}`);
     const lines = messages.map((msg) => JSON.stringify({ type: "message", ...msg }));
-    await fs46.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs47.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.saveIndex(index);
   }
@@ -44486,17 +44243,17 @@ var SlashCommands_default = SlashCommands;
 import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
-import { fileURLToPath as fileURLToPath6 } from "url";
-import path53 from "path";
-import fs47 from "fs";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import path54 from "path";
+import fs48 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
 function findBlumaPackageJson(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
-    const candidate = path53.join(dir, "package.json");
-    if (fs47.existsSync(candidate)) {
+    const candidate = path54.join(dir, "package.json");
+    if (fs48.existsSync(candidate)) {
       try {
-        const raw = fs47.readFileSync(candidate, "utf8");
+        const raw = fs48.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -44504,7 +44261,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path53.dirname(dir);
+    const parent = path54.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -44513,13 +44270,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path53.resolve(dir);
+    const abs = path54.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path53.dirname(fileURLToPath6(import.meta.url)));
+    const fromBundle = tryFrom(path54.dirname(fileURLToPath7(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -44527,12 +44284,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path53.isAbsolute(argv1) && fs47.existsSync(argv1)) {
-        resolved = fs47.realpathSync(argv1);
+      if (path54.isAbsolute(argv1) && fs48.existsSync(argv1)) {
+        resolved = fs48.realpathSync(argv1);
       } else {
-        resolved = path53.resolve(process.cwd(), argv1);
+        resolved = path54.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path53.dirname(resolved));
+      const fromArgv = tryFrom(path54.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -45351,16 +45108,16 @@ function usePlanMode() {
 
 // src/app/hooks/useAgentMode.ts
 import { useState as useState22, useEffect as useEffect21, useCallback as useCallback9 } from "react";
-import * as fs48 from "fs";
-import * as path54 from "path";
+import * as fs49 from "fs";
+import * as path55 from "path";
 import { homedir as homedir4 } from "os";
-var SETTINGS_PATH = path54.join(homedir4(), ".bluma", "settings.json");
+var SETTINGS_PATH = path55.join(homedir4(), ".bluma", "settings.json");
 function readAgentModeFromFile() {
   try {
-    if (!fs48.existsSync(SETTINGS_PATH)) {
+    if (!fs49.existsSync(SETTINGS_PATH)) {
       return "default";
     }
-    const content = fs48.readFileSync(SETTINGS_PATH, "utf-8");
+    const content = fs49.readFileSync(SETTINGS_PATH, "utf-8");
     const settings = JSON.parse(content);
     return settings.agentMode || "default";
   } catch (error) {
@@ -45379,16 +45136,16 @@ function useAgentMode() {
   }, []);
   const updateAgentMode = useCallback9((mode) => {
     try {
-      if (!fs48.existsSync(SETTINGS_PATH)) {
-        fs48.mkdirSync(path54.dirname(SETTINGS_PATH), { recursive: true });
+      if (!fs49.existsSync(SETTINGS_PATH)) {
+        fs49.mkdirSync(path55.dirname(SETTINGS_PATH), { recursive: true });
       }
       let settings = {};
-      if (fs48.existsSync(SETTINGS_PATH)) {
-        const content = fs48.readFileSync(SETTINGS_PATH, "utf-8");
+      if (fs49.existsSync(SETTINGS_PATH)) {
+        const content = fs49.readFileSync(SETTINGS_PATH, "utf-8");
         settings = JSON.parse(content);
       }
       settings.agentMode = mode;
-      fs48.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+      fs49.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
       setAgentMode(mode);
     } catch (error) {
       console.error("Failed to update agent mode:", error);
@@ -46652,10 +46409,10 @@ import { memo as memo26, useCallback as useCallback11, useEffect as useEffect23,
 
 // src/app/agent/session_manager/session_resume_browser.ts
 init_bluma_app_dir();
-import path55 from "path";
-import { promises as fs49 } from "fs";
+import path56 from "path";
+import { promises as fs50 } from "fs";
 function getSessionsRoot() {
-  return path55.join(getPreferredAppDir(), "sessions");
+  return path56.join(getPreferredAppDir(), "sessions");
 }
 function normalizeSessionsCwd(cwd2) {
   return cwd2.replace(/\\/g, "/").split("/").filter((p) => p && p !== "." && p !== "..").join("/");
@@ -46676,9 +46433,9 @@ async function sessionEntryFromFile(absPath, sessionId) {
   let preview = "(no messages)";
   let lastActivityMs = Date.now();
   try {
-    const st = await fs49.stat(absPath);
+    const st = await fs50.stat(absPath);
     lastActivityMs = st.mtimeMs;
-    const raw = await fs49.readFile(absPath, "utf-8");
+    const raw = await fs50.readFile(absPath, "utf-8");
     const data = JSON.parse(raw);
     preview = previewFromHistory(data.conversation_history);
     const iso = data.last_updated || data.created_at;
@@ -46706,15 +46463,15 @@ function compareDirNames(a, b) {
 async function listSessionBrowserEntries(cwdRel) {
   const cwd2 = normalizeSessionsCwd(cwdRel);
   const root = getSessionsRoot();
-  const absDir = cwd2 ? path55.join(root, ...cwd2.split("/")) : root;
+  const absDir = cwd2 ? path56.join(root, ...cwd2.split("/")) : root;
   const out = [];
   if (cwd2) {
     out.push({ kind: "up", label: ".." });
   }
   let dirents;
   try {
-    await fs49.mkdir(absDir, { recursive: true });
-    dirents = await fs49.readdir(absDir, { withFileTypes: true });
+    await fs50.mkdir(absDir, { recursive: true });
+    dirents = await fs50.readdir(absDir, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -46723,7 +46480,7 @@ async function listSessionBrowserEntries(cwdRel) {
   for (const e of dirents) {
     const name = String(e.name);
     if (name.startsWith(".")) continue;
-    const full = path55.join(absDir, name);
+    const full = path56.join(absDir, name);
     if (e.isDirectory()) {
       dirNames.push(name);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -46733,7 +46490,7 @@ async function listSessionBrowserEntries(cwdRel) {
   dirNames.sort(compareDirNames);
   const sessions = [];
   for (const { name, full } of sessionFiles) {
-    const sessionId = path55.basename(name, ".json");
+    const sessionId = path56.basename(name, ".json");
     sessions.push(await sessionEntryFromFile(full, sessionId));
   }
   sessions.sort((a, b) => {
@@ -47098,9 +46855,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs50.readFileSync(filePath, "utf-8");
+      rawPayload = fs51.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs50.readFileSync(0, "utf-8");
+      rawPayload = fs51.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -47341,9 +47098,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path56.dirname(fileURLToPath7(import.meta.url));
-    const pkgPath = path56.join(base, "..", "package.json");
-    const j = JSON.parse(fs50.readFileSync(pkgPath, "utf8"));
+    const base = path57.dirname(fileURLToPath8(import.meta.url));
+    const pkgPath = path57.join(base, "..", "package.json");
+    const j = JSON.parse(fs51.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -47469,7 +47226,7 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs50.readFileSync(filePath, "utf-8");
+  const rawPayload = fs51.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
   const sessionId = envelope.session_id || envelope.message_id || uuidv412();
   registerSession({