@nomad-e/bluma-cli 0.1.40 → 0.1.41

package/dist/main.js

@@ -9,6 +9,106 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/app/agent/runtime/sandbox_policy.ts
+import path5 from "path";
+function getSandboxPolicy() {
+  const isSandbox = process.env.BLUMA_SANDBOX === "true";
+  const workspaceRoot = path5.resolve(
+    process.env.BLUMA_SANDBOX_WORKSPACE || process.cwd()
+  );
+  return {
+    mode: isSandbox ? "workspace" : "local",
+    isSandbox,
+    workspaceRoot
+  };
+}
+function isPathInsideWorkspace(targetPath, policy = getSandboxPolicy()) {
+  const resolved = path5.resolve(targetPath);
+  const relative = path5.relative(policy.workspaceRoot, resolved);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function resolveWorkspacePath(inputPath, policy = getSandboxPolicy()) {
+  const candidate = path5.isAbsolute(inputPath) ? path5.resolve(inputPath) : path5.resolve(policy.workspaceRoot, inputPath);
+  if (policy.isSandbox && !isPathInsideWorkspace(candidate, policy)) {
+    throw new Error(
+      `Path "${inputPath}" escapes the sandbox workspace root ${policy.workspaceRoot}`
+    );
+  }
+  return candidate;
+}
+function resolveCommandCwd(cwd, policy = getSandboxPolicy()) {
+  const base = cwd ? path5.resolve(cwd) : policy.workspaceRoot;
+  if (policy.isSandbox && !isPathInsideWorkspace(base, policy)) {
+    throw new Error(
+      `Command cwd "${base}" escapes the sandbox workspace root ${policy.workspaceRoot}`
+    );
+  }
+  return base;
+}
+function assessCommandSafety(command, policy = getSandboxPolicy()) {
+  const trimmed = String(command || "").trim();
+  if (!trimmed) {
+    return { allowed: false, risk: "blocked", reason: "Command is required." };
+  }
+  for (const entry of BLOCKED_COMMAND_PATTERNS) {
+    if (entry.pattern.test(trimmed)) {
+      return { allowed: false, risk: "blocked", reason: entry.reason };
+    }
+  }
+  if (HIGH_RISK_COMMAND_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+    return {
+      allowed: true,
+      risk: policy.isSandbox ? "high" : "high",
+      reason: policy.isSandbox ? "High-risk command allowed inside the workspace sandbox." : "High-risk command requires explicit approval outside sandbox mode."
+    };
+  }
+  if (MODERATE_RISK_COMMAND_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+    return {
+      allowed: true,
+      risk: "moderate",
+      reason: policy.isSandbox ? "Workspace mutation command allowed inside the sandbox." : "Workspace mutation command requires confirmation outside sandbox mode."
+    };
+  }
+  return { allowed: true, risk: "safe" };
+}
+var BLOCKED_COMMAND_PATTERNS, HIGH_RISK_COMMAND_PATTERNS, MODERATE_RISK_COMMAND_PATTERNS;
+var init_sandbox_policy = __esm({
+  "src/app/agent/runtime/sandbox_policy.ts"() {
+    "use strict";
+    BLOCKED_COMMAND_PATTERNS = [
+      { pattern: /^sudo\s+/i, reason: "Privilege escalation is not allowed." },
+      { pattern: /^doas\s+/i, reason: "Privilege escalation is not allowed." },
+      { pattern: /^su\s+/i, reason: "Privilege escalation is not allowed." },
+      { pattern: /^pkexec\s+/i, reason: "Privilege escalation is not allowed." },
+      { pattern: /\bmkfs\./i, reason: "Disk formatting commands are blocked." },
+      { pattern: /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i, reason: "Raw disk writes are blocked." },
+      { pattern: /\brm\s+(-[rf]+\s+)*\/($|\s)/i, reason: "Deleting filesystem roots is blocked." },
+      { pattern: /\brm\s+-[rf]*\s+~($|\s)/i, reason: "Deleting home roots is blocked." },
+      { pattern: /\bcurl\s+.*\|\s*(ba)?sh/i, reason: "Pipe-to-shell remote execution is blocked." },
+      { pattern: /\bwget\s+.*\|\s*(ba)?sh/i, reason: "Pipe-to-shell remote execution is blocked." }
+    ];
+    HIGH_RISK_COMMAND_PATTERNS = [
+      /\brm\s+-[rf]/i,
+      /\bmv\s+.+\s+\/(?!tmp\b)/i,
+      /\bchmod\b/i,
+      /\bchown\b/i,
+      /\bssh\b/i,
+      /\bscp\b/i,
+      /\brsync\b/i,
+      /\bdocker\b/i,
+      /\bkubectl\b/i
+    ];
+    MODERATE_RISK_COMMAND_PATTERNS = [
+      /\bnpm\s+(install|update|uninstall)\b/i,
+      /\bpnpm\s+(add|install|update|remove)\b/i,
+      /\byarn\s+(add|install|remove)\b/i,
+      /\buv\s+(add|remove|sync)\b/i,
+      /\bpip\s+install\b/i,
+      /\bgit\s+(commit|push|rebase|reset|clean)\b/i
+    ];
+  }
+});
+
 // src/app/agent/tools/natives/async_command.ts
 var async_command_exports = {};
 __export(async_command_exports, {
@@ -30,10 +130,10 @@ function cleanupOldCommands() {
 }
 function isDangerousCommand(command) {
   const trimmed = command.trim();
-  for (const pattern of DANGEROUS_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return "Command requires elevated privileges (sudo/doas) which cannot be handled in async mode";
-    }
+  const policy = getSandboxPolicy();
+  const assessment = assessCommandSafety(trimmed, policy);
+  if (!assessment.allowed) {
+    return assessment.reason || "Command blocked by sandbox policy";
   }
   for (const pattern of INTERACTIVE_PATTERNS) {
     if (pattern.test(trimmed)) {
@@ -46,7 +146,7 @@ async function runCommandAsync(args) {
   try {
     const {
       command,
-      cwd = process.cwd(),
+      cwd,
       timeout = 0
     } = args;
     if (!command || typeof command !== "string") {
@@ -62,6 +162,8 @@ async function runCommandAsync(args) {
         error: dangerReason
       };
     }
+    const policy = getSandboxPolicy();
+    const resolvedCwd = resolveCommandCwd(cwd, policy);
     const commandId = uuidv42().substring(0, 8);
     const platform = os5.platform();
     let shellCmd;
@@ -84,7 +186,7 @@ async function runCommandAsync(args) {
       process: null
     };
     const child = spawn2(shellCmd, shellArgs, {
-      cwd,
+      cwd: resolvedCwd,
       env: process.env,
       windowsHide: true
     });
@@ -286,35 +388,15 @@ async function killCommand(args) {
     };
   }
 }
-var runningCommands, MAX_OUTPUT_SIZE, MAX_STORED_COMMANDS, OUTPUT_TRUNCATION_MSG, DANGEROUS_PATTERNS, INTERACTIVE_PATTERNS;
+var runningCommands, MAX_OUTPUT_SIZE, MAX_STORED_COMMANDS, OUTPUT_TRUNCATION_MSG, INTERACTIVE_PATTERNS;
 var init_async_command = __esm({
   "src/app/agent/tools/natives/async_command.ts"() {
     "use strict";
+    init_sandbox_policy();
     runningCommands = /* @__PURE__ */ new Map();
     MAX_OUTPUT_SIZE = 3e4;
     MAX_STORED_COMMANDS = 50;
     OUTPUT_TRUNCATION_MSG = "\n[OUTPUT TRUNCATED - 30KB/200 lines max]";
-    DANGEROUS_PATTERNS = [
-      // Elevação de privilégios
-      /^sudo\s+/i,
-      /^doas\s+/i,
-      /^su\s+/i,
-      /^pkexec\s+/i,
-      /\|\s*sudo\s+/i,
-      /;\s*sudo\s+/i,
-      /&&\s*sudo\s+/i,
-      // Comandos destrutivos
-      /\brm\s+(-[rf]+\s+)*[\/~]/i,
-      /\brm\s+-[rf]*\s+\*/i,
-      /\bchmod\s+(777|666)\s+\//i,
-      /\bdd\s+.*of=\/dev\/(sd|hd|nvme)/i,
-      /\bmkfs\./i,
-      // Fork bombs
-      /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
-      // Remote code exec
-      /\bcurl\s+.*\|\s*(ba)?sh/i,
-      /\bwget\s+.*\|\s*(ba)?sh/i
-    ];
     INTERACTIVE_PATTERNS = [
       /^(vim|vi|nano|emacs|pico)\s*/i,
       /^(less|more|most)\s*/i,
@@ -331,14 +413,15 @@ var init_async_command = __esm({
 import React12 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter3 } from "events";
-import fs18 from "fs";
-import path22 from "path";
+import fs21 from "fs";
+import path26 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { v4 as uuidv46 } from "uuid";
+import { spawn as spawn4 } from "child_process";
+import { v4 as uuidv47 } from "uuid";
 
 // src/app/ui/App.tsx
 import { useState as useState6, useEffect as useEffect7, useRef as useRef5, useCallback as useCallback3, memo as memo12 } from "react";
-import { Box as Box20, Text as Text19, Static } from "ink";
+import { Box as Box20, Text as Text20, Static } from "ink";
 
 // src/app/ui/layout.tsx
 import { Box, Text, useStdout } from "ink";
@@ -391,7 +474,9 @@ var HeaderComponent = ({
   sessionId,
   workdir,
   cliVersion = "?",
-  recentActivitySummary
+  recentActivitySummary,
+  activeTaskSummary,
+  taskProgressSummary
 }) => {
   const { stdout } = useStdout();
   const cols = Math.max(52, stdout?.columns ?? 80);
@@ -466,6 +551,10 @@ var HeaderComponent = ({
           "as needed."
         ] }),
         /* @__PURE__ */ jsx(Box, { marginY: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(ruleW) }) }),
+        /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: "Work in progress" }) }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: activeTaskSummary?.trim() ? activeTaskSummary.trim() : "No active task." }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: taskProgressSummary?.trim() ? taskProgressSummary.trim() : "No tracked todo items." }),
+        /* @__PURE__ */ jsx(Box, { marginY: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(ruleW) }) }),
         /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: "Recent activity" }) }),
         /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: recentActivitySummary?.trim() ? recentActivitySummary.trim() : "No recent activity." })
       ] }),
@@ -1973,10 +2062,28 @@ import { Box as Box4, Text as Text4 } from "ink";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var SimpleDiff = ({ text, maxHeight }) => {
   const allLines = (text || "").split("\n").filter((line) => line !== "");
+  const additions = allLines.filter((line) => line.startsWith("+") && !line.startsWith("+++")).length;
+  const removals = allLines.filter((line) => line.startsWith("-") && !line.startsWith("---")).length;
+  const hunks = allLines.filter((line) => line.startsWith("@@")).length;
   const isTruncated = maxHeight > 0 && allLines.length > maxHeight;
   const linesToRender = isTruncated ? allLines.slice(-maxHeight) : allLines;
   const hiddenCount = allLines.length - linesToRender.length;
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingX: 2, children: [
+    /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: BLUMA_TERMINAL.brandMagenta, children: "diff" }),
+      /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        " \xB7 +",
+        additions,
+        " -",
+        removals
+      ] }),
+      hunks > 0 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        " \xB7 ",
+        hunks,
+        " hunk",
+        hunks > 1 ? "s" : ""
+      ] }) : null
+    ] }),
     isTruncated && /* @__PURE__ */ jsx4(Box4, { marginBottom: 0, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
       "\u22EF ",
       hiddenCount,
@@ -1984,26 +2091,26 @@ var SimpleDiff = ({ text, maxHeight }) => {
     ] }) }),
     linesToRender.map((line, index) => {
       if (line.startsWith("---") || line.startsWith("+++")) {
-        return null;
+        return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: line }) }, index);
       }
       let color = "white";
       let prefix = "";
       if (line.startsWith("+")) {
-        color = "green";
+        color = BLUMA_TERMINAL.success;
         prefix = "+ ";
       } else if (line.startsWith("-")) {
-        color = "red";
+        color = BLUMA_TERMINAL.err;
         prefix = "- ";
       } else if (line.startsWith("@@")) {
-        color = "cyan";
-        prefix = "";
+        color = BLUMA_TERMINAL.brandBlue;
+        prefix = "@ ";
       } else {
-        color = "gray";
+        color = BLUMA_TERMINAL.muted;
         prefix = "  ";
       }
       return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { color, children: [
         prefix,
-        line.replace(/^[+\-]/, "")
+        line.replace(/^[@+\-]\s?/, "")
       ] }) }, index);
     })
   ] });
@@ -2317,16 +2424,17 @@ var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path20 from "path";
-import os14 from "os";
+import path24 from "path";
+import os16 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs11 } from "fs";
-import path13 from "path";
+import { promises as fs14 } from "fs";
+import path17 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/agent/tools/natives/edit.ts
-import path5 from "path";
+init_sandbox_policy();
+import path6 from "path";
 import os4 from "os";
 import { promises as fs4 } from "fs";
 import { diffLines } from "diff";
@@ -2345,7 +2453,7 @@ function normalizePath(filePath) {
       }
       filePath = filePath.replace(/\//g, "\\");
     }
-    return path5.normalize(path5.resolve(filePath));
+    return path6.normalize(resolveWorkspacePath(filePath));
   } catch (e) {
     throw new Error(`Failed to normalize path "${filePath}": ${e.message}`);
   }
@@ -2606,7 +2714,7 @@ async function editTool(args) {
       };
     }
     const cwd = process.cwd();
-    if (!normalizedFilePath.startsWith(cwd) && !path5.isAbsolute(file_path)) {
+    if (!normalizedFilePath.startsWith(cwd) && !path6.isAbsolute(file_path)) {
       return {
         success: false,
         error: `Invalid parameters: file_path must be within the current working directory or be an absolute path.`,
@@ -2627,11 +2735,11 @@ async function editTool(args) {
         file_path: normalizedFilePath
       };
     }
-    const dirPath = path5.dirname(normalizedFilePath);
+    const dirPath = path6.dirname(normalizedFilePath);
     await fs4.mkdir(dirPath, { recursive: true });
     await fs4.writeFile(normalizedFilePath, editData.newContent, "utf-8");
-    const relativePath = path5.relative(process.cwd(), normalizedFilePath);
-    const filename = path5.basename(normalizedFilePath);
+    const relativePath = path6.relative(process.cwd(), normalizedFilePath);
+    const filename = path6.basename(normalizedFilePath);
     if (editData.isNewFile) {
       return {
         success: true,
@@ -2686,7 +2794,7 @@ function message(args) {
 
 // src/app/agent/tools/natives/ls.ts
 import { promises as fs5 } from "fs";
-import path6 from "path";
+import path7 from "path";
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   ".git",
   ".gitignore",
@@ -2714,7 +2822,7 @@ async function ls(args) {
     max_depth
   } = args;
   try {
-    const basePath = path6.resolve(directory_path);
+    const basePath = path7.resolve(directory_path);
     if (!(await fs5.stat(basePath)).isDirectory()) {
       throw new Error(`Directory '${directory_path}' not found.`);
     }
@@ -2727,8 +2835,8 @@ async function ls(args) {
       const entries = await fs5.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         const entryName = entry.name;
-        const fullPath = path6.join(currentDir, entryName);
-        const posixPath = fullPath.split(path6.sep).join("/");
+        const fullPath = path7.join(currentDir, entryName);
+        const posixPath = fullPath.split(path7.sep).join("/");
         const isHidden = entryName.startsWith(".");
         if (allIgnorePatterns.has(entryName) || isHidden && !show_hidden) {
           continue;
@@ -2739,7 +2847,7 @@ async function ls(args) {
             await walk(fullPath, currentDepth + 1);
           }
         } else if (entry.isFile()) {
-          if (!normalizedExtensions || normalizedExtensions.includes(path6.extname(entryName).toLowerCase())) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path7.extname(entryName).toLowerCase())) {
             allFiles.push(posixPath);
           }
         }
@@ -2750,7 +2858,7 @@ async function ls(args) {
     allDirs.sort();
     return {
       success: true,
-      path: basePath.split(path6.sep).join("/"),
+      path: basePath.split(path7.sep).join("/"),
       recursive,
       total_files: allFiles.length,
       total_directories: allDirs.length,
@@ -2766,17 +2874,19 @@ async function ls(args) {
 }
 
 // src/app/agent/tools/natives/readLines.ts
+init_sandbox_policy();
 import { promises as fs6 } from "fs";
 async function readLines(args) {
   const { filepath, start_line, end_line } = args;
   try {
-    if (!(await fs6.stat(filepath)).isFile()) {
+    const resolvedPath = resolveWorkspacePath(filepath);
+    if (!(await fs6.stat(resolvedPath)).isFile()) {
       throw new Error(`File '${filepath}' not found or is not a file.`);
     }
     if (start_line < 1 || end_line < start_line) {
       throw new Error("Invalid line range. start_line must be >= 1 and end_line must be >= start_line.");
     }
-    const fileContent = await fs6.readFile(filepath, "utf-8");
+    const fileContent = await fs6.readFile(resolvedPath, "utf-8");
     const lines = fileContent.split("\n");
     const total_lines = lines.length;
     const startIndex = start_line - 1;
@@ -2789,7 +2899,7 @@ async function readLines(args) {
     const content = contentLines.join("\n");
     return {
       success: true,
-      filepath,
+      filepath: resolvedPath,
       content,
       lines_read: contentLines.length,
       start_line,
@@ -2827,178 +2937,209 @@ async function countLines(args) {
   }
 }
 
-// src/app/agent/tools/natives/todo.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
-var taskStore = [];
-var nextId = 1;
-function getTodoFilePath() {
-  return path7.join(process.cwd(), ".bluma", "todo.json");
+// src/app/agent/runtime/task_store.ts
+init_sandbox_policy();
+import fs8 from "fs";
+import path8 from "path";
+var cache = null;
+function getStorePath() {
+  const policy = getSandboxPolicy();
+  return path8.join(policy.workspaceRoot, ".bluma", "task_state.json");
 }
-function loadTasksFromFile() {
-  try {
-    const filePath = getTodoFilePath();
-    if (fs8.existsSync(filePath)) {
-      const data = fs8.readFileSync(filePath, "utf-8");
-      const parsed = JSON.parse(data);
-      if (Array.isArray(parsed.tasks)) {
-        taskStore = parsed.tasks;
-        nextId = parsed.nextId || taskStore.length + 1;
-      }
-    }
-  } catch {
-  }
+function getDefaultState() {
+  return {
+    tasks: [],
+    nextId: 1,
+    activeTask: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-function saveTasksToFile() {
+function ensureLoaded() {
+  if (cache) {
+    return cache;
+  }
+  const storePath = getStorePath();
   try {
-    const filePath = getTodoFilePath();
-    const dir = path7.dirname(filePath);
-    if (!fs8.existsSync(dir)) {
-      fs8.mkdirSync(dir, { recursive: true });
+    if (fs8.existsSync(storePath)) {
+      const raw = fs8.readFileSync(storePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      cache = {
+        tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
+        nextId: typeof parsed.nextId === "number" ? parsed.nextId : 1,
+        activeTask: parsed.activeTask ?? null,
+        updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return cache;
     }
-    fs8.writeFileSync(filePath, JSON.stringify({
-      tasks: taskStore,
-      nextId,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }, null, 2));
   } catch {
   }
-}
-function calculateStats() {
-  const total = taskStore.length;
-  const pending = taskStore.filter((t) => t.status === "pending").length;
-  const inProgress = taskStore.filter((t) => t.status === "in_progress").length;
-  const completed = taskStore.filter((t) => t.status === "completed").length;
+  cache = getDefaultState();
+  return cache;
+}
+function persist(state) {
+  const storePath = getStorePath();
+  fs8.mkdirSync(path8.dirname(storePath), { recursive: true });
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  fs8.writeFileSync(storePath, JSON.stringify(state, null, 2), "utf-8");
+  cache = state;
+}
+function updateTaskStore(mutator) {
+  const current = ensureLoaded();
+  const clone = {
+    tasks: current.tasks.map((task) => ({ ...task })),
+    nextId: current.nextId,
+    activeTask: current.activeTask ? { ...current.activeTask } : null,
+    updatedAt: current.updatedAt
+  };
+  mutator(clone);
+  persist(clone);
+  return clone;
+}
+function calculateTaskStats(tasks) {
+  const total = tasks.length;
+  const pending = tasks.filter((t) => t.status === "pending").length;
+  const inProgress = tasks.filter((t) => t.status === "in_progress").length;
+  const completed = tasks.filter((t) => t.status === "completed").length;
   const progress = total > 0 ? Math.round(completed / total * 100) : 0;
   return { total, pending, inProgress, completed, progress };
 }
+function buildTaskSnapshot() {
+  const state = ensureLoaded();
+  return {
+    tasks: state.tasks.map((task) => ({ ...task })),
+    activeTask: state.activeTask ? { ...state.activeTask } : null,
+    stats: calculateTaskStats(state.tasks),
+    updatedAt: state.updatedAt
+  };
+}
+
+// src/app/agent/tools/natives/todo.ts
 function validateDescription(desc) {
-  if (!desc || typeof desc !== "string") {
-    return "Description is required";
-  }
-  if (desc.trim().length === 0) {
-    return "Description cannot be empty";
-  }
-  if (desc.length > 500) {
-    return "Description too long (max 500 chars)";
-  }
+  if (!desc || typeof desc !== "string") return "Description is required";
+  if (desc.trim().length === 0) return "Description cannot be empty";
+  if (desc.length > 500) return "Description too long (max 500 chars)";
   return null;
 }
+function generateProgressBar(percent) {
+  const width = 10;
+  const filled = Math.round(percent / 100 * width);
+  return "[" + "=".repeat(filled) + " ".repeat(width - filled) + "]";
+}
 function createResult(success, message2) {
+  const snapshot = buildTaskSnapshot();
   return {
     success,
     message: message2,
-    tasks: taskStore,
-    stats: calculateStats()
+    tasks: snapshot.tasks,
+    activeTask: snapshot.activeTask,
+    stats: snapshot.stats
   };
 }
-function listTasks() {
-  loadTasksFromFile();
-  const stats = calculateStats();
-  if (taskStore.length === 0) {
-    return createResult(true, "No tasks yet. Use add action to create tasks.");
-  }
-  const progressBar = generateProgressBar(stats.progress);
-  return createResult(true, `${stats.total} tasks ${progressBar} ${stats.progress}%`);
+function syncTasks(tasks) {
+  updateTaskStore((state) => {
+    state.tasks = [];
+    state.nextId = 1;
+    for (const task of tasks || []) {
+      state.tasks.push({
+        id: state.nextId++,
+        description: task.description,
+        status: task.isComplete ? "completed" : "pending",
+        priority: task.priority || "medium",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+      });
+    }
+  });
+  const snapshot = buildTaskSnapshot();
+  const progressBar = generateProgressBar(snapshot.stats.progress);
+  return createResult(
+    true,
+    `Synced ${snapshot.tasks.length} tasks ${progressBar} ${snapshot.stats.progress}%`
+  );
 }
 function addTasks(tasks) {
   if (!tasks || tasks.length === 0) {
     return createResult(false, "No tasks provided");
   }
-  loadTasksFromFile();
   for (const task of tasks) {
     const error = validateDescription(task.description);
-    if (error) {
-      return createResult(false, `Invalid task: ${error}`);
-    }
-    const newTask = {
-      id: nextId++,
-      description: task.description.trim(),
-      status: task.isComplete ? "completed" : "pending",
-      priority: task.priority || "medium",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
-    };
-    taskStore.push(newTask);
-  }
-  saveTasksToFile();
+    if (error) return createResult(false, `Invalid task: ${error}`);
+  }
+  updateTaskStore((state) => {
+    for (const task of tasks) {
+      state.tasks.push({
+        id: state.nextId++,
+        description: task.description.trim(),
+        status: task.isComplete ? "completed" : "pending",
+        priority: task.priority || "medium",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+      });
+    }
+  });
   return createResult(true, `Added ${tasks.length} task(s)`);
 }
 function completeTask(taskId) {
-  loadTasksFromFile();
-  const task = taskStore.find((t) => t.id === taskId);
-  if (!task) {
-    return createResult(false, `Task #${taskId} not found`);
-  }
-  task.status = "completed";
-  task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-  saveTasksToFile();
-  return createResult(true, `Completed: ${task.description}`);
+  let found = false;
+  let description = "";
+  updateTaskStore((state) => {
+    const task = state.tasks.find((item) => item.id === taskId);
+    if (!task) return;
+    found = true;
+    description = task.description;
+    task.status = "completed";
+    task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  });
+  return found ? createResult(true, `Completed: ${description}`) : createResult(false, `Task #${taskId} not found`);
 }
 function updateTask(taskId, description, priority) {
-  loadTasksFromFile();
-  const task = taskStore.find((t) => t.id === taskId);
-  if (!task) {
-    return createResult(false, `Task #${taskId} not found`);
-  }
   if (description) {
     const error = validateDescription(description);
-    if (error) {
-      return createResult(false, error);
-    }
-    task.description = description.trim();
-  }
-  if (priority) {
-    task.priority = priority;
-  }
-  saveTasksToFile();
-  return createResult(true, `Updated task #${taskId}`);
+    if (error) return createResult(false, error);
+  }
+  let found = false;
+  updateTaskStore((state) => {
+    const task = state.tasks.find((item) => item.id === taskId);
+    if (!task) return;
+    found = true;
+    if (description) task.description = description.trim();
+    if (priority) task.priority = priority;
+  });
+  return found ? createResult(true, `Updated task #${taskId}`) : createResult(false, `Task #${taskId} not found`);
 }
 function removeTask(taskId) {
-  loadTasksFromFile();
-  const index = taskStore.findIndex((t) => t.id === taskId);
-  if (index === -1) {
-    return createResult(false, `Task #${taskId} not found`);
-  }
-  const removed = taskStore.splice(index, 1)[0];
-  saveTasksToFile();
-  return createResult(true, `Removed: ${removed.description}`);
+  let removedDescription = "";
+  updateTaskStore((state) => {
+    const index = state.tasks.findIndex((item) => item.id === taskId);
+    if (index === -1) return;
+    removedDescription = state.tasks[index].description;
+    state.tasks.splice(index, 1);
+  });
+  return removedDescription ? createResult(true, `Removed: ${removedDescription}`) : createResult(false, `Task #${taskId} not found`);
 }
 function clearCompleted() {
-  loadTasksFromFile();
-  const before = taskStore.length;
-  taskStore = taskStore.filter((t) => t.status !== "completed");
-  const removed = before - taskStore.length;
-  saveTasksToFile();
+  let removed = 0;
+  updateTaskStore((state) => {
+    const before = state.tasks.length;
+    state.tasks = state.tasks.filter((task) => task.status !== "completed");
+    removed = before - state.tasks.length;
+  });
   return createResult(true, `Cleared ${removed} completed task(s)`);
 }
-function generateProgressBar(percent) {
-  const width = 10;
-  const filled = Math.round(percent / 100 * width);
-  const empty = width - filled;
-  return "[" + "=".repeat(filled) + " ".repeat(empty) + "]";
+function listTasks() {
+  const snapshot = buildTaskSnapshot();
+  if (snapshot.tasks.length === 0) {
+    return createResult(true, "No tasks yet. Use add action to create tasks.");
+  }
+  const progressBar = generateProgressBar(snapshot.stats.progress);
+  return createResult(
+    true,
+    `${snapshot.stats.total} tasks ${progressBar} ${snapshot.stats.progress}%`
+  );
 }
 async function todo(args) {
   if ("tasks" in args && !("action" in args)) {
-    loadTasksFromFile();
-    taskStore = [];
-    nextId = 1;
-    if (args.tasks && args.tasks.length > 0) {
-      for (const task of args.tasks) {
-        taskStore.push({
-          id: nextId++,
-          description: task.description,
-          status: task.isComplete ? "completed" : "pending",
-          priority: "medium",
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          completedAt: task.isComplete ? (/* @__PURE__ */ new Date()).toISOString() : void 0
-        });
-      }
-    }
-    saveTasksToFile();
-    const stats = calculateStats();
-    const progressBar = generateProgressBar(stats.progress);
-    return createResult(true, `Synced ${taskStore.length} tasks ${progressBar} ${stats.progress}%`);
+    return syncTasks(args.tasks);
   }
   const fullArgs = args;
   switch (fullArgs.action) {
@@ -3007,31 +3148,22 @@ async function todo(args) {
     case "add":
       return addTasks(fullArgs.tasks);
     case "complete":
-      if (!fullArgs.taskId) {
-        return createResult(false, "taskId required for complete action");
-      }
-      return completeTask(fullArgs.taskId);
+      return fullArgs.taskId ? completeTask(fullArgs.taskId) : createResult(false, "taskId required for complete action");
     case "update":
-      if (!fullArgs.taskId) {
-        return createResult(false, "taskId required for update action");
-      }
-      return updateTask(fullArgs.taskId, fullArgs.description, fullArgs.priority);
+      return fullArgs.taskId ? updateTask(fullArgs.taskId, fullArgs.description, fullArgs.priority) : createResult(false, "taskId required for update action");
     case "remove":
-      if (!fullArgs.taskId) {
-        return createResult(false, "taskId required for remove action");
-      }
-      return removeTask(fullArgs.taskId);
+      return fullArgs.taskId ? removeTask(fullArgs.taskId) : createResult(false, "taskId required for remove action");
     case "clear":
       return clearCompleted();
     case "sync":
-      return addTasks(fullArgs.tasks);
+      return syncTasks(fullArgs.tasks);
     default:
       return createResult(false, `Unknown action: ${fullArgs.action}`);
   }
 }
 
 // src/app/agent/tools/natives/find_by_name.ts
-import path8 from "path";
+import path9 from "path";
 import { promises as fsPromises } from "fs";
 var DEFAULT_IGNORE_PATTERNS = [
   "node_modules",
@@ -3071,7 +3203,7 @@ function shouldIgnore(name, ignorePatterns, includeHidden) {
 }
 function matchesExtensions(filename, extensions) {
   if (!extensions || extensions.length === 0) return true;
-  const ext = path8.extname(filename).toLowerCase();
+  const ext = path9.extname(filename).toLowerCase();
   return extensions.some((e) => {
     const normalizedExt = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
     return ext === normalizedExt;
@@ -3093,8 +3225,8 @@ async function searchDirectory(dir, pattern, baseDir, options, results) {
     if (shouldIgnore(name, options.ignorePatterns, options.includeHidden)) {
       continue;
     }
-    const fullPath = path8.join(dir, name);
-    const relativePath = path8.relative(baseDir, fullPath);
+    const fullPath = path9.join(dir, name);
+    const relativePath = path9.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (pattern.test(name)) {
         results.push({
@@ -3150,7 +3282,7 @@ async function findByName(args) {
         error: "Pattern is required and must be a string"
       };
     }
-    const resolvedDir = path8.resolve(directory);
+    const resolvedDir = path9.resolve(directory);
     try {
       const stats = await fsPromises.stat(resolvedDir);
       if (!stats.isDirectory()) {
@@ -3211,7 +3343,7 @@ async function findByName(args) {
 }
 
 // src/app/agent/tools/natives/grep_search.ts
-import path9 from "path";
+import path10 from "path";
 import { promises as fsPromises2 } from "fs";
 var MAX_RESULTS3 = 100;
 var MAX_FILE_SIZE2 = 1024 * 1024;
@@ -3294,8 +3426,8 @@ var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   "Rakefile"
 ]);
 function isTextFile(filepath) {
-  const ext = path9.extname(filepath).toLowerCase();
-  const basename = path9.basename(filepath);
+  const ext = path10.extname(filepath).toLowerCase();
+  const basename = path10.basename(filepath);
   if (TEXT_EXTENSIONS.has(ext)) return true;
   if (TEXT_EXTENSIONS.has(basename)) return true;
   if (basename.startsWith(".") && !ext) return true;
@@ -3340,7 +3472,7 @@ async function searchFile(filepath, baseDir, pattern, contextLines, matches, max
     if (stats.size > MAX_FILE_SIZE2) return 0;
     const content = await fsPromises2.readFile(filepath, "utf-8");
     const lines = content.split("\n");
-    const relativePath = path9.relative(baseDir, filepath);
+    const relativePath = path10.relative(baseDir, filepath);
     for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
       const line = lines[i];
       pattern.lastIndex = 0;
@@ -3380,7 +3512,7 @@ async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextL
     if (matches.length >= maxResults) break;
     const name = entry.name;
     if (shouldIgnore2(name)) continue;
-    const fullPath = path9.join(dir, name);
+    const fullPath = path10.join(dir, name);
     if (entry.isDirectory()) {
       await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats);
     } else if (entry.isFile()) {
@@ -3429,7 +3561,7 @@ async function grepSearch(args) {
         error: "Search path is required"
       };
     }
-    const resolvedPath = path9.resolve(searchPath);
+    const resolvedPath = path10.resolve(searchPath);
     let stats;
     try {
       stats = await fsPromises2.stat(resolvedPath);
@@ -3477,7 +3609,7 @@ async function grepSearch(args) {
       );
     } else if (stats.isFile()) {
       searchStats.filesSearched = 1;
-      const found = await searchFile(resolvedPath, path9.dirname(resolvedPath), pattern, context_lines, matches, max_results);
+      const found = await searchFile(resolvedPath, path10.dirname(resolvedPath), pattern, context_lines, matches, max_results);
       if (found > 0) searchStats.filesWithMatches = 1;
     }
     return {
@@ -3506,7 +3638,7 @@ async function grepSearch(args) {
 }
 
 // src/app/agent/tools/natives/view_file_outline.ts
-import path10 from "path";
+import path11 from "path";
 import { promises as fsPromises3 } from "fs";
 var LANGUAGE_MAP = {
   ".ts": "typescript",
@@ -3620,7 +3752,7 @@ var PATTERNS = {
   ]
 };
 function detectLanguage(filepath) {
-  const ext = path10.extname(filepath).toLowerCase();
+  const ext = path11.extname(filepath).toLowerCase();
   return LANGUAGE_MAP[ext] || "unknown";
 }
 function determineItemType(line, language) {
@@ -3716,7 +3848,7 @@ async function viewFileOutline(args) {
         error: "file_path is required and must be a string"
       };
     }
-    const resolvedPath = path10.resolve(file_path);
+    const resolvedPath = path11.resolve(file_path);
     let content;
     try {
       content = await fsPromises3.readFile(resolvedPath, "utf-8");
@@ -3756,27 +3888,28 @@ async function viewFileOutline(args) {
   }
 }
 
-// src/app/agent/tool_invoker.ts
+// src/app/agent/runtime/native_tool_catalog.ts
 init_async_command();
 
 // src/app/agent/tools/natives/task_boundary.ts
-import path11 from "path";
+init_sandbox_policy();
+import path12 from "path";
 import { promises as fs9 } from "fs";
 import os6 from "os";
-var currentTask = null;
 var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
+  const policy = getSandboxPolicy();
   const homeDir = os6.homedir();
-  const baseDir = path11.join(homeDir, ".bluma", "artifacts");
+  const baseDir = policy.isSandbox ? path12.join(policy.workspaceRoot, "artifacts") : path12.join(homeDir, ".bluma", "artifacts");
   const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
-  artifactsDir = path11.join(baseDir, sessionId);
+  artifactsDir = path12.join(baseDir, sessionId);
   await fs9.mkdir(artifactsDir, { recursive: true });
   return artifactsDir;
 }
 async function updateTaskFile(task) {
   const dir = await getArtifactsDir();
-  const taskFile = path11.join(dir, "task.md");
+  const taskFile = path12.join(dir, "task.md");
   const content = `# ${task.taskName}
 
 **Mode:** ${task.mode}  
@@ -3821,32 +3954,58 @@ async function taskBoundary(args) {
       };
     }
     const now = Date.now();
-    if (currentTask && currentTask.taskName === task_name) {
-      currentTask.mode = mode;
-      currentTask.status = task_status;
-      currentTask.summary = task_summary || currentTask.summary;
-      currentTask.updateTime = now;
-      currentTask.stepCount++;
-    } else {
-      currentTask = {
-        taskName: task_name,
+    let currentTask = null;
+    updateTaskStore((state) => {
+      if (state.activeTask && state.activeTask.taskName === task_name) {
+        state.activeTask.mode = mode;
+        state.activeTask.status = task_status;
+        state.activeTask.summary = task_summary || state.activeTask.summary;
+        state.activeTask.updateTime = now;
+        state.activeTask.stepCount++;
+      } else {
+        state.activeTask = {
+          taskName: task_name,
+          mode,
+          status: task_status,
+          summary: task_summary || "",
+          startTime: now,
+          updateTime: now,
+          stepCount: 1
+        };
+      }
+      currentTask = state.activeTask;
+    });
+    if (!currentTask) {
+      return {
+        success: false,
+        task_name,
+        mode,
+        status: task_status,
+        message: "Failed to persist active task"
+      };
+    }
+    const snapshot = buildTaskSnapshot();
+    const persistedTask = snapshot.activeTask;
+    if (!persistedTask) {
+      return {
+        success: false,
+        task_name,
         mode,
         status: task_status,
-        summary: task_summary || "",
-        startTime: now,
-        updateTime: now,
-        stepCount: 1
+        message: "Task persisted without an active snapshot"
       };
     }
-    await updateTaskFile(currentTask);
+    await updateTaskFile(persistedTask);
     const dir = await getArtifactsDir();
     return {
       success: true,
-      task_name: currentTask.taskName,
-      mode: currentTask.mode,
-      status: currentTask.status,
+      task_name: persistedTask.taskName,
+      mode: persistedTask.mode,
+      status: persistedTask.status,
       message: `Task "${task_name}" is now in ${mode} mode. Status: ${task_status}`,
-      artifacts_dir: dir
+      artifacts_dir: dir,
+      activeTask: snapshot.activeTask,
+      stats: snapshot.stats
     };
   } catch (error) {
     return {
@@ -3868,7 +4027,7 @@ async function createArtifact(args) {
       return { success: false, error: "content is required" };
     }
     const dir = await getArtifactsDir();
-    const filepath = path11.join(dir, filename);
+    const filepath = path12.join(dir, filename);
     await fs9.writeFile(filepath, content, "utf-8");
     return {
       success: true,
@@ -3888,7 +4047,7 @@ async function readArtifact(args) {
       return { success: false, error: "filename is required" };
     }
     const dir = await getArtifactsDir();
-    const filepath = path11.join(dir, filename);
+    const filepath = path12.join(dir, filename);
     const content = await fs9.readFile(filepath, "utf-8");
     return {
       success: true,
@@ -4259,7 +4418,7 @@ ${skill.content}`;
 
 // src/app/agent/tools/natives/coding_memory.ts
 import * as fs10 from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 import os7 from "os";
 var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
 var PROMPT_DEFAULT_MAX_NOTES = 25;
@@ -4268,13 +4427,13 @@ function readCodingMemoryForPrompt(options) {
   const maxTotal = options?.maxTotalChars ?? PROMPT_DEFAULT_MAX_TOTAL;
   const maxNotes = options?.maxNotes ?? PROMPT_DEFAULT_MAX_NOTES;
   const preview = options?.previewCharsPerNote ?? PROMPT_DEFAULT_PREVIEW;
-  const globalPath = path12.join(os7.homedir(), ".bluma", "coding_memory.json");
-  const legacyPath = path12.join(process.cwd(), ".bluma", "coding_memory.json");
+  const globalPath = path13.join(os7.homedir(), ".bluma", "coding_memory.json");
+  const legacyPath = path13.join(process.cwd(), ".bluma", "coding_memory.json");
   let raw = null;
   try {
     if (fs10.existsSync(globalPath)) {
       raw = fs10.readFileSync(globalPath, "utf-8");
-    } else if (path12.resolve(globalPath) !== path12.resolve(legacyPath) && fs10.existsSync(legacyPath)) {
+    } else if (path13.resolve(globalPath) !== path13.resolve(legacyPath) && fs10.existsSync(legacyPath)) {
       raw = fs10.readFileSync(legacyPath, "utf-8");
     }
   } catch {
@@ -4310,29 +4469,29 @@ ${block}` : block;
   return parts.join("");
 }
 var memoryStore = [];
-var nextId2 = 1;
+var nextId = 1;
 var loaded = false;
 function getMemoryFilePath() {
-  return path12.join(os7.homedir(), ".bluma", "coding_memory.json");
+  return path13.join(os7.homedir(), ".bluma", "coding_memory.json");
 }
 function getLegacyMemoryFilePath() {
-  return path12.join(process.cwd(), ".bluma", "coding_memory.json");
+  return path13.join(process.cwd(), ".bluma", "coding_memory.json");
 }
 function loadMemoryFromFile() {
   if (loaded) return;
   loaded = true;
   memoryStore = [];
-  nextId2 = 1;
+  nextId = 1;
   try {
     const filePath = getMemoryFilePath();
     const legacy = getLegacyMemoryFilePath();
-    const legacyDistinct = path12.resolve(legacy) !== path12.resolve(filePath);
+    const legacyDistinct = path13.resolve(legacy) !== path13.resolve(filePath);
     const readIntoStore = (p) => {
       const raw = fs10.readFileSync(p, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.entries)) {
         memoryStore = parsed.entries;
-        nextId2 = typeof parsed.nextId === "number" ? parsed.nextId : memoryStore.length + 1;
+        nextId = typeof parsed.nextId === "number" ? parsed.nextId : memoryStore.length + 1;
       }
     };
     if (fs10.existsSync(filePath)) {
@@ -4346,19 +4505,19 @@ function loadMemoryFromFile() {
     }
   } catch {
     memoryStore = [];
-    nextId2 = 1;
+    nextId = 1;
   }
 }
 function saveMemoryToFile() {
   try {
     const filePath = getMemoryFilePath();
-    const dir = path12.dirname(filePath);
+    const dir = path13.dirname(filePath);
     if (!fs10.existsSync(dir)) {
       fs10.mkdirSync(dir, { recursive: true });
     }
     const payload = {
       entries: memoryStore,
-      nextId: nextId2,
+      nextId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     fs10.writeFileSync(filePath, JSON.stringify(payload, null, 2));
@@ -4387,7 +4546,7 @@ function addNote(args) {
     };
   }
   const entry = {
-    id: nextId2++,
+    id: nextId++,
     note,
     tags: normalizeTags(args.tags),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4512,44 +4671,698 @@ function updateNote(args) {
   if (hasTags) {
     entry.tags = normalizeTags(args.tags);
   }
-  saveMemoryToFile();
-  return {
-    success: true,
-    message: `Updated coding memory id=${id}`,
-    entries: memoryStore
-  };
+  saveMemoryToFile();
+  return {
+    success: true,
+    message: `Updated coding memory id=${id}`,
+    entries: memoryStore
+  };
+}
+async function coding_memory(args) {
+  const action = args.action;
+  switch (action) {
+    case "add":
+      return addNote(args);
+    case "list":
+      return listNotes();
+    case "search":
+      return searchNotes(args);
+    case "remove":
+      return removeNote(args);
+    case "update":
+      return updateNote(args);
+    default:
+      return {
+        success: false,
+        message: `Unknown action: ${String(action)}`,
+        entries: memoryStore
+      };
+  }
+}
+
+// src/app/agent/tools/natives/file_write.ts
+init_sandbox_policy();
+import { promises as fs11 } from "fs";
+import path14 from "path";
+async function fileWrite(args) {
+  const {
+    filepath,
+    content,
+    overwrite = true,
+    create_directories = true
+  } = args;
+  try {
+    if (!filepath || typeof filepath !== "string") {
+      return { success: false, error: "filepath is required" };
+    }
+    if (content === void 0 || content === null) {
+      return { success: false, error: "content is required" };
+    }
+    const resolvedPath = resolveWorkspacePath(filepath);
+    const dir = path14.dirname(resolvedPath);
+    let existed = false;
+    try {
+      const st = await fs11.stat(resolvedPath);
+      existed = st.isFile();
+    } catch {
+      existed = false;
+    }
+    if (existed && !overwrite) {
+      return {
+        success: false,
+        error: `File already exists and overwrite=false: ${resolvedPath}`
+      };
+    }
+    if (create_directories) {
+      await fs11.mkdir(dir, { recursive: true });
+    }
+    await fs11.writeFile(resolvedPath, String(content), "utf-8");
+    const bytes = Buffer.byteLength(String(content), "utf-8");
+    return {
+      success: true,
+      filepath: resolvedPath,
+      bytes_written: bytes,
+      created: !existed,
+      overwritten: existed
+    };
+  } catch (error) {
+    return { success: false, error: error.message || String(error) };
+  }
+}
+
+// src/app/agent/tools/natives/web_fetch.ts
+import http2 from "http";
+import https2 from "https";
+var DEFAULT_MAX_CHARS = 12e3;
+var REQUEST_TIMEOUT_MS = 15e3;
+function fetchUrl(url) {
+  return new Promise((resolve2, reject) => {
+    const client = url.startsWith("https://") ? https2 : http2;
+    const req = client.get(
+      url,
+      {
+        headers: {
+          "User-Agent": "bluma-cli/0.1",
+          Accept: "text/plain,text/html,application/json;q=0.9,*/*;q=0.5"
+        },
+        timeout: REQUEST_TIMEOUT_MS
+      },
+      (res) => {
+        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          fetchUrl(res.headers.location).then(resolve2).catch(reject);
+          return;
+        }
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        res.on("end", () => {
+          resolve2({
+            statusCode: res.statusCode,
+            contentType: res.headers["content-type"],
+            body
+          });
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy(new Error("Request timeout"));
+    });
+  });
+}
+function stripHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\s+/g, " ").trim();
+}
+async function webFetch(args) {
+  const maxChars = Math.max(500, Math.min(args.max_chars ?? DEFAULT_MAX_CHARS, 5e4));
+  const url = String(args.url || "").trim();
+  if (!/^https?:\/\//i.test(url)) {
+    return {
+      success: false,
+      url,
+      error: "url must start with http:// or https://"
+    };
+  }
+  try {
+    const response = await fetchUrl(url);
+    const contentType = response.contentType || "unknown";
+    const raw = /html/i.test(contentType) ? stripHtml(response.body) : response.body.trim();
+    const truncated = raw.length > maxChars;
+    const content = truncated ? `${raw.slice(0, maxChars)}
+
+[...truncated...]` : raw;
+    return {
+      success: true,
+      url,
+      status_code: response.statusCode,
+      content_type: contentType,
+      content,
+      truncated
+    };
+  } catch (error) {
+    return {
+      success: false,
+      url,
+      error: error.message || String(error)
+    };
+  }
+}
+
+// src/app/agent/tools/natives/agent_coordination.ts
+import fs13 from "fs";
+import os9 from "os";
+import path16 from "path";
+import { spawn as spawn3 } from "child_process";
+import { v4 as uuidv43 } from "uuid";
+
+// src/app/agent/runtime/session_registry.ts
+import fs12 from "fs";
+import os8 from "os";
+import path15 from "path";
+function getRegistryDir() {
+  return path15.join(process.env.HOME || os8.homedir(), ".bluma", "registry");
+}
+function getRegistryFile() {
+  return path15.join(getRegistryDir(), "sessions.json");
+}
+function ensureRegistryDir() {
+  fs12.mkdirSync(getRegistryDir(), { recursive: true });
+}
+function readRegistry() {
+  ensureRegistryDir();
+  const file = getRegistryFile();
+  if (!fs12.existsSync(file)) {
+    return { entries: [] };
+  }
+  try {
+    return JSON.parse(fs12.readFileSync(file, "utf-8"));
+  } catch {
+    return { entries: [] };
+  }
+}
+function writeRegistry(state) {
+  ensureRegistryDir();
+  fs12.writeFileSync(getRegistryFile(), JSON.stringify(state, null, 2), "utf-8");
+}
+function getSessionLogPath(sessionId) {
+  ensureRegistryDir();
+  return path15.join(getRegistryDir(), `${sessionId}.jsonl`);
+}
+function registerSession(entry) {
+  const state = readRegistry();
+  const nextEntry = {
+    ...entry,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    logFile: getSessionLogPath(entry.sessionId)
+  };
+  state.entries = state.entries.filter((item) => item.sessionId !== entry.sessionId);
+  state.entries.unshift(nextEntry);
+  writeRegistry(state);
+  return nextEntry;
+}
+function updateSession(sessionId, patch) {
+  const state = readRegistry();
+  const index = state.entries.findIndex((entry) => entry.sessionId === sessionId);
+  if (index === -1) return null;
+  const nextEntry = {
+    ...state.entries[index],
+    ...patch,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  state.entries[index] = nextEntry;
+  writeRegistry(state);
+  return nextEntry;
+}
+function listSessions() {
+  return readRegistry().entries;
+}
+function getSession(sessionId) {
+  return readRegistry().entries.find((entry) => entry.sessionId === sessionId) || null;
+}
+function appendSessionLog(sessionId, payload) {
+  const logFile = getSessionLogPath(sessionId);
+  fs12.appendFileSync(logFile, `${JSON.stringify(payload)}
+`, "utf-8");
+}
+function readSessionLog(sessionId) {
+  const logFile = getSessionLogPath(sessionId);
+  if (!fs12.existsSync(logFile)) return [];
+  return fs12.readFileSync(logFile, "utf-8").split("\n").filter(Boolean);
+}
+
+// src/app/agent/tools/natives/agent_coordination.ts
+function buildWorkerPayload(sessionId, args, parentSessionId) {
+  return {
+    message_id: sessionId,
+    session_id: sessionId,
+    from_agent: parentSessionId || "interactive",
+    to_agent: "bluma-worker",
+    action: "worker_task",
+    context: {
+      user_request: args.task,
+      coordinator_context: args.context || null,
+      worker_title: args.title || null,
+      worker_role: args.agent_type || "worker"
+    },
+    metadata: {
+      sandbox: process.env.BLUMA_SANDBOX === "true",
+      sandbox_name: process.env.BLUMA_SANDBOX_NAME || void 0,
+      coordinator_worker: true,
+      parent_session_id: parentSessionId
+    }
+  };
+}
+function extractLatestResult(sessionId) {
+  const lines = readSessionLog(sessionId);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    try {
+      const parsed = JSON.parse(lines[index]);
+      if (parsed.event_type === "result") {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function toAgentSummary(entry) {
+  return {
+    session_id: entry.sessionId,
+    title: entry.title,
+    kind: entry.kind,
+    status: entry.status,
+    started_at: entry.startedAt,
+    updated_at: entry.updatedAt,
+    pid: entry.pid || null,
+    metadata: entry.metadata || {}
+  };
+}
+async function spawnAgent(args) {
+  if (!args?.task || typeof args.task !== "string") {
+    return { success: false, error: "task is required" };
+  }
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    return { success: false, error: "Unable to resolve CLI entrypoint for worker spawn" };
+  }
+  const sessionId = uuidv43();
+  const parentSessionId = process.env.BLUMA_SESSION_ID || null;
+  const title = args.title || `worker:${args.agent_type || "worker"}`;
+  const payload = buildWorkerPayload(sessionId, args, parentSessionId);
+  const payloadDir = fs13.mkdtempSync(path16.join(os9.tmpdir(), "bluma-worker-"));
+  const payloadPath = path16.join(payloadDir, `${sessionId}.json`);
+  fs13.writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
+  registerSession({
+    sessionId,
+    kind: "agent",
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workdir: process.cwd(),
+    title,
+    metadata: {
+      action: "worker_task",
+      background: true,
+      coordinator_worker: true,
+      parent_session_id: parentSessionId,
+      agent_type: args.agent_type || "worker"
+    }
+  });
+  const child = spawn3(
+    process.execPath,
+    [entrypoint, "agent", "--input-file", payloadPath, "--background-worker", "--registry-session", sessionId],
+    {
+      detached: true,
+      stdio: "ignore",
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        BLUMA_PARENT_SESSION_ID: parentSessionId || ""
+      }
+    }
+  );
+  child.unref();
+  updateSession(sessionId, { pid: child.pid });
+  return {
+    success: true,
+    session_id: sessionId,
+    pid: child.pid || null,
+    parent_session_id: parentSessionId,
+    title,
+    status: "running"
+  };
+}
+async function waitAgent(args) {
+  const sessionId = args?.session_id;
+  if (!sessionId || typeof sessionId !== "string") {
+    return { success: false, error: "session_id is required" };
+  }
+  const timeoutMs = Math.max(1e3, Number(args.timeout_ms || 3e4));
+  const pollIntervalMs = Math.max(200, Number(args.poll_interval_ms || 1e3));
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const session2 = getSession(sessionId);
+    if (!session2) {
+      return { success: false, error: `Unknown session: ${sessionId}` };
+    }
+    if (session2.status !== "running") {
+      return {
+        success: true,
+        completed: true,
+        session: toAgentSummary(session2),
+        result: extractLatestResult(sessionId)
+      };
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+  }
+  const session = getSession(sessionId);
+  if (!session) {
+    return { success: false, error: `Unknown session: ${sessionId}` };
+  }
+  return {
+    success: true,
+    completed: false,
+    session: toAgentSummary(session),
+    result: extractLatestResult(sessionId),
+    message: `Timed out after ${timeoutMs}ms while waiting for agent ${sessionId}.`
+  };
+}
+async function listAgents(args = {}) {
+  const entries = listSessions().filter((entry) => entry.kind === "agent").filter((entry) => {
+    if (args.parent_session_id) {
+      return entry.metadata?.parent_session_id === args.parent_session_id;
+    }
+    return true;
+  }).filter((entry) => {
+    if (args.status) {
+      return entry.status === args.status;
+    }
+    return true;
+  }).map(toAgentSummary);
+  return {
+    success: true,
+    count: entries.length,
+    agents: entries
+  };
+}
+
+// src/app/agent/runtime/native_tool_catalog.ts
+var NATIVE_TOOL_ENTRIES = [
+  {
+    metadata: {
+      name: "message",
+      category: "communication",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Deliver progress or result messages to the user."
+    },
+    implementation: message
+  },
+  {
+    metadata: {
+      name: "todo",
+      category: "planning",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Track a task list for the current objective."
+    },
+    implementation: todo
+  },
+  {
+    metadata: {
+      name: "task_boundary",
+      category: "planning",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Track the current task mode and execution boundary."
+    },
+    implementation: taskBoundary
+  },
+  {
+    metadata: {
+      name: "create_artifact",
+      category: "artifact",
+      riskLevel: "write",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Write a generated artifact into the artifact output area."
+    },
+    implementation: createArtifact
+  },
+  {
+    metadata: {
+      name: "read_artifact",
+      category: "artifact",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Read an artifact from the artifact output area."
+    },
+    implementation: readArtifact
+  },
+  {
+    metadata: {
+      name: "ls_tool",
+      category: "filesystem",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "List files and directories."
+    },
+    implementation: ls
+  },
+  {
+    metadata: {
+      name: "count_file_lines",
+      category: "filesystem",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Count lines in a text file."
+    },
+    implementation: countLines
+  },
+  {
+    metadata: {
+      name: "read_file_lines",
+      category: "filesystem",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Read a slice of a text file."
+    },
+    implementation: readLines
+  },
+  {
+    metadata: {
+      name: "find_by_name",
+      category: "filesystem",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Find files by glob pattern."
+    },
+    implementation: findByName
+  },
+  {
+    metadata: {
+      name: "grep_search",
+      category: "filesystem",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Search file contents."
+    },
+    implementation: grepSearch
+  },
+  {
+    metadata: {
+      name: "view_file_outline",
+      category: "filesystem",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Inspect the outline of a source file."
+    },
+    implementation: viewFileOutline
+  },
+  {
+    metadata: {
+      name: "edit_tool",
+      category: "filesystem",
+      riskLevel: "write",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      description: "Edit or create files in the workspace."
+    },
+    implementation: editTool
+  },
+  {
+    metadata: {
+      name: "file_write",
+      category: "filesystem",
+      riskLevel: "write",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      description: "Write full file contents directly into the workspace."
+    },
+    implementation: fileWrite
+  },
+  {
+    metadata: {
+      name: "shell_command",
+      category: "execution",
+      riskLevel: "execute",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      description: "Execute a shell command in the workspace."
+    },
+    implementation: runCommandAsync
+  },
+  {
+    metadata: {
+      name: "command_status",
+      category: "execution",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Inspect the status of an async command."
+    },
+    implementation: commandStatus
+  },
+  {
+    metadata: {
+      name: "send_command_input",
+      category: "execution",
+      riskLevel: "execute",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      description: "Send stdin to a running command."
+    },
+    implementation: sendCommandInput
+  },
+  {
+    metadata: {
+      name: "kill_command",
+      category: "execution",
+      riskLevel: "execute",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      description: "Terminate a running command."
+    },
+    implementation: killCommand
+  },
+  {
+    metadata: {
+      name: "spawn_agent",
+      category: "execution",
+      riskLevel: "execute",
+      autoApproveInLocal: false,
+      autoApproveInSandbox: true,
+      description: "Spawn a background worker agent for a bounded subtask."
+    },
+    implementation: spawnAgent
+  },
+  {
+    metadata: {
+      name: "wait_agent",
+      category: "execution",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Wait for a worker agent session to finish and collect its result."
+    },
+    implementation: waitAgent
+  },
+  {
+    metadata: {
+      name: "list_agents",
+      category: "execution",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "List worker and agent sessions known to the coordinator."
+    },
+    implementation: listAgents
+  },
+  {
+    metadata: {
+      name: "search_web",
+      category: "knowledge",
+      riskLevel: "network",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Search external sources through the configured provider."
+    },
+    implementation: searchWeb
+  },
+  {
+    metadata: {
+      name: "web_fetch",
+      category: "knowledge",
+      riskLevel: "network",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Fetch the contents of a remote URL for analysis."
+    },
+    implementation: webFetch
+  },
+  {
+    metadata: {
+      name: "load_skill",
+      category: "knowledge",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Load a pluggable skill module."
+    },
+    implementation: loadSkill
+  },
+  {
+    metadata: {
+      name: "coding_memory",
+      category: "knowledge",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Persist or retrieve durable project notes."
+    },
+    implementation: coding_memory
+  }
+];
+var TOOL_METADATA_MAP = new Map(
+  NATIVE_TOOL_ENTRIES.map((entry) => [entry.metadata.name, entry.metadata])
+);
+var TOOL_IMPLEMENTATION_MAP = new Map(
+  NATIVE_TOOL_ENTRIES.map((entry) => [entry.metadata.name, entry.implementation])
+);
+function getNativeToolMetadata(toolName) {
+  return TOOL_METADATA_MAP.get(toolName);
 }
-async function coding_memory(args) {
-  const action = args.action;
-  switch (action) {
-    case "add":
-      return addNote(args);
-    case "list":
-      return listNotes();
-    case "search":
-      return searchNotes(args);
-    case "remove":
-      return removeNote(args);
-    case "update":
-      return updateNote(args);
-    default:
-      return {
-        success: false,
-        message: `Unknown action: ${String(action)}`,
-        entries: memoryStore
-      };
-  }
+function getNativeToolImplementation(toolName) {
+  return TOOL_IMPLEMENTATION_MAP.get(toolName);
+}
+function getAllNativeToolMetadata() {
+  return NATIVE_TOOL_ENTRIES.map((entry) => entry.metadata);
+}
+function applyMetadataToToolDefinitions(toolDefinitions) {
+  return toolDefinitions.map((definition) => {
+    const toolName = definition.function.name;
+    return {
+      ...definition,
+      metadata: getNativeToolMetadata(toolName)
+    };
+  });
 }
 
 // src/app/agent/tool_invoker.ts
 var ToolInvoker = class {
-  // Mapa privado para associar nomes de ferramentas às suas funções de implementação.
-  toolImplementations;
   // Propriedade privada para armazenar as definições de ferramentas carregadas do JSON.
   toolDefinitions = [];
   constructor() {
-    this.toolImplementations = /* @__PURE__ */ new Map();
-    this.registerTools();
   }
   /**
    * Carrega as definições de ferramentas do arquivo de configuração `native_tools.json`.
@@ -4558,41 +5371,16 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path13.dirname(__filename);
-      const configPath = path13.resolve(__dirname, "config", "native_tools.json");
-      const fileContent = await fs11.readFile(configPath, "utf-8");
+      const __dirname = path17.dirname(__filename);
+      const configPath = path17.resolve(__dirname, "config", "native_tools.json");
+      const fileContent = await fs14.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
-      this.toolDefinitions = config2.nativeTools;
+      this.toolDefinitions = applyMetadataToToolDefinitions(config2.nativeTools);
     } catch (error) {
       console.error("[ToolInvoker] Erro cr\xEDtico ao carregar 'native_tools.json'. As ferramentas nativas n\xE3o estar\xE3o dispon\xEDveis.", error);
       this.toolDefinitions = [];
     }
   }
-  /**
-   * Registra as implementações de todas as ferramentas nativas.
-   * Este método mapeia o nome da ferramenta (string) para a função TypeScript que a executa.
-   */
-  registerTools() {
-    this.toolImplementations.set("edit_tool", editTool);
-    this.toolImplementations.set("ls_tool", ls);
-    this.toolImplementations.set("count_file_lines", countLines);
-    this.toolImplementations.set("read_file_lines", readLines);
-    this.toolImplementations.set("find_by_name", findByName);
-    this.toolImplementations.set("grep_search", grepSearch);
-    this.toolImplementations.set("view_file_outline", viewFileOutline);
-    this.toolImplementations.set("shell_command", runCommandAsync);
-    this.toolImplementations.set("command_status", commandStatus);
-    this.toolImplementations.set("send_command_input", sendCommandInput);
-    this.toolImplementations.set("kill_command", killCommand);
-    this.toolImplementations.set("message", message);
-    this.toolImplementations.set("todo", todo);
-    this.toolImplementations.set("task_boundary", taskBoundary);
-    this.toolImplementations.set("create_artifact", createArtifact);
-    this.toolImplementations.set("read_artifact", readArtifact);
-    this.toolImplementations.set("search_web", searchWeb);
-    this.toolImplementations.set("load_skill", loadSkill);
-    this.toolImplementations.set("coding_memory", coding_memory);
-  }
   /**
    * Retorna a lista de definições de todas as ferramentas nativas carregadas.
    * O MCPClient usará esta função para obter a lista de ferramentas locais.
@@ -4600,6 +5388,12 @@ var ToolInvoker = class {
   getToolDefinitions() {
     return this.toolDefinitions;
   }
+  getToolMetadata(toolName) {
+    return getNativeToolMetadata(toolName);
+  }
+  getAllToolMetadata() {
+    return getAllNativeToolMetadata();
+  }
   /**
    * Invoca uma ferramenta nativa pelo nome com os argumentos fornecidos.
    * @param toolName O nome da ferramenta a ser invocada.
@@ -4607,7 +5401,7 @@ var ToolInvoker = class {
    * @returns O resultado da execução da ferramenta.
    */
   async invoke(toolName, args) {
-    const implementation = this.toolImplementations.get(toolName);
+    const implementation = getNativeToolImplementation(toolName);
     if (!implementation) {
       return { error: `Error: Native tool "${toolName}" not found.` };
     }
@@ -4621,9 +5415,9 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs12 } from "fs";
-import path14 from "path";
-import os8 from "os";
+import { promises as fs15 } from "fs";
+import path18 from "path";
+import os10 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -4650,9 +5444,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    const __dirname = path14.dirname(__filename);
-    const defaultConfigPath = path14.resolve(__dirname, "config", "bluma-mcp.json");
-    const userConfigPath = path14.join(os8.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname = path18.dirname(__filename);
+    const defaultConfigPath = path18.resolve(__dirname, "config", "bluma-mcp.json");
+    const userConfigPath = path18.join(os10.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -4686,7 +5480,7 @@ var MCPClient = class {
   }
   async loadMcpConfig(configPath, configType) {
     try {
-      const fileContent = await fs12.readFile(configPath, "utf-8");
+      const fileContent = await fs15.readFile(configPath, "utf-8");
       const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
@@ -4705,7 +5499,7 @@ var MCPClient = class {
   async connectToStdioServer(serverName, config2) {
     let commandToExecute = config2.command;
     let argsToExecute = config2.args || [];
-    const isWindows = os8.platform() === "win32";
+    const isWindows = os10.platform() === "win32";
     if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
       if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
         commandToExecute = argsToExecute[1];
@@ -4770,7 +5564,13 @@ var MCPClient = class {
       const route = this.toolToServerMap.get(name);
       if (!route) continue;
       const source = route.server === "native" ? "native" : "mcp";
-      detailed.push({ ...tool, source, server: route.server, originalName: route.originalName });
+      detailed.push({
+        ...tool,
+        source,
+        server: route.server,
+        originalName: route.originalName,
+        metadata: source === "native" ? this.nativeToolInvoker.getToolMetadata(route.originalName) : void 0
+      });
     }
     return detailed;
   }
@@ -4821,13 +5621,13 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path19 from "path";
-import { v4 as uuidv43 } from "uuid";
+import path23 from "path";
+import { v4 as uuidv44 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path15 from "path";
-import os9 from "os";
-import { promises as fs13 } from "fs";
+import path19 from "path";
+import os11 from "os";
+import { promises as fs16 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -4863,13 +5663,13 @@ function debouncedSave(sessionFile, history, memory) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path15.join(os9.homedir(), p.slice(1));
+    return path19.join(os11.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path15.join(os9.homedir(), ".bluma");
-  return path15.resolve(expandHome(fixed));
+  const fixed = path19.join(os11.homedir(), ".bluma");
+  return path19.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -4877,10 +5677,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path15.dirname(dest);
-      await fs13.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path19.dirname(dest);
+      await fs16.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs13.rename(src, dest);
+      await fs16.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -4893,13 +5693,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs13.access(src);
-    const data = await fs13.readFile(src);
-    const dir = path15.dirname(dest);
-    await fs13.mkdir(dir, { recursive: true }).catch(() => {
+    await fs16.access(src);
+    const data = await fs16.readFile(src);
+    const dir = path19.dirname(dest);
+    await fs16.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs13.writeFile(dest, data);
-    await fs13.unlink(src).catch(() => {
+    await fs16.writeFile(dest, data);
+    await fs16.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -4912,16 +5712,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path15.join(appDir, "sessions");
-  await fs13.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path19.join(appDir, "sessions");
+  await fs16.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadOrcreateSession(sessionId) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path15.join(sessionDir, `${sessionId}.json`);
+  const sessionFile = path19.join(sessionDir, `${sessionId}.json`);
   try {
-    await fs13.access(sessionFile);
-    const fileContent = await fs13.readFile(sessionFile, "utf-8");
+    await fs16.access(sessionFile);
+    const fileContent = await fs16.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     const memory = {
       historyAnchor: sessionData.history_anchor ?? null,
@@ -4934,7 +5734,7 @@ async function loadOrcreateSession(sessionId) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
-    await fs13.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    await fs16.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     const emptyMemory = {
       historyAnchor: null,
       compressedTurnSliceCount: 0
@@ -4946,12 +5746,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path15.dirname(sessionFile);
-      await fs13.mkdir(dir, { recursive: true });
+      const dir = path19.dirname(sessionFile);
+      await fs16.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs13.readFile(sessionFile, "utf-8");
+      const fileContent = await fs16.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -4962,14 +5762,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path15.basename(sessionFile, ".json");
+      const sessionId = path19.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs13.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs16.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -4985,7 +5785,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     }
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs13.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs16.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -4994,7 +5794,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs13.unlink(tempSessionFile);
+        await fs16.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -5011,15 +5811,15 @@ async function saveSessionHistory(sessionFile, history, memory) {
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
-import os11 from "os";
-import fs16 from "fs";
-import path18 from "path";
+import os13 from "os";
+import fs19 from "fs";
+import path22 from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs14 from "fs";
-import path16 from "path";
-import os10 from "os";
+import fs17 from "fs";
+import path20 from "path";
+import os12 from "os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var SkillLoader = class _SkillLoader {
   bundledSkillsDir;
@@ -5028,8 +5828,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path16.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path16.join(os10.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path20.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path20.join(os12.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -5038,48 +5838,48 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path16.join(process.cwd(), "dist", "config", "skills");
+      return path20.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path16.resolve(p);
+      const abs = path20.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path16.dirname(fileURLToPath3(import.meta.url));
-      push(path16.join(bundleDir, "config", "skills"));
+      const bundleDir = path20.dirname(fileURLToPath3(import.meta.url));
+      push(path20.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path16.isAbsolute(argv1) && fs14.existsSync(argv1)) {
-          resolved = fs14.realpathSync(argv1);
-        } else if (!path16.isAbsolute(argv1)) {
-          resolved = path16.resolve(process.cwd(), argv1);
+        if (path20.isAbsolute(argv1) && fs17.existsSync(argv1)) {
+          resolved = fs17.realpathSync(argv1);
+        } else if (!path20.isAbsolute(argv1)) {
+          resolved = path20.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path16.dirname(resolved);
-        argvBundled = path16.join(scriptDir, "config", "skills");
+        const scriptDir = path20.dirname(resolved);
+        argvBundled = path20.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
     }
     for (const abs of candidates) {
-      if (fs14.existsSync(abs)) {
+      if (fs17.existsSync(abs)) {
         return abs;
       }
     }
     try {
-      return path16.join(path16.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
+      return path20.join(path20.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path16.join(os10.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path20.join(os12.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -5108,8 +5908,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path16.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path16.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path20.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path20.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -5117,20 +5917,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs14.existsSync(dir)) return [];
+    if (!fs17.existsSync(dir)) return [];
     try {
-      return fs14.readdirSync(dir).filter((d) => {
-        const fullPath = path16.join(dir, d);
-        return fs14.statSync(fullPath).isDirectory() && fs14.existsSync(path16.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path16.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs17.readdirSync(dir).filter((d) => {
+        const fullPath = path20.join(dir, d);
+        return fs17.statSync(fullPath).isDirectory() && fs17.existsSync(path20.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path20.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs14.existsSync(skillPath)) return null;
+    if (!fs17.existsSync(skillPath)) return null;
     try {
-      const raw = fs14.readFileSync(skillPath, "utf-8");
+      const raw = fs17.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -5152,12 +5952,12 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path16.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path16.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path16.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs14.existsSync(bundledPath);
-    const existsProject = fs14.existsSync(projectPath);
-    const existsGlobal = fs14.existsSync(globalPath);
+    const bundledPath = path20.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path20.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path20.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs17.existsSync(bundledPath);
+    const existsProject = fs17.existsSync(projectPath);
+    const existsGlobal = fs17.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -5196,9 +5996,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs14.readFileSync(skillPath, "utf-8");
+      const raw = fs17.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path16.dirname(skillPath);
+      const skillDir = path20.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -5207,22 +6007,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path16.join(skillDir, "references")),
-        scripts: this.scanAssets(path16.join(skillDir, "scripts"))
+        references: this.scanAssets(path20.join(skillDir, "references")),
+        scripts: this.scanAssets(path20.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs14.existsSync(dir)) return [];
+    if (!fs17.existsSync(dir)) return [];
     try {
-      return fs14.readdirSync(dir).filter((f) => {
-        const fp = path16.join(dir, f);
-        return fs14.statSync(fp).isFile();
+      return fs17.readdirSync(dir).filter((f) => {
+        const fp = path20.join(dir, f);
+        return fs17.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path16.resolve(dir, f)
+        path: path20.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -5279,10 +6079,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path16.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path16.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path16.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs14.existsSync(bundledPath) || fs14.existsSync(projectPath) || fs14.existsSync(globalPath);
+    const bundledPath = path20.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path20.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path20.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs17.existsSync(bundledPath) || fs17.existsSync(projectPath) || fs17.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -5314,8 +6114,8 @@ var SkillLoader = class _SkillLoader {
 };
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
-import fs15 from "fs";
-import path17 from "path";
+import fs18 from "fs";
+import path21 from "path";
 import { execSync } from "child_process";
 var LIMITS = {
   readme: 1e4,
@@ -5330,10 +6130,10 @@ var LIMITS = {
 };
 function safeReadFile(filePath, maxChars) {
   try {
-    if (!fs15.existsSync(filePath)) return null;
-    const st = fs15.statSync(filePath);
+    if (!fs18.existsSync(filePath)) return null;
+    const st = fs18.statSync(filePath);
     if (!st.isFile()) return null;
-    const raw = fs15.readFileSync(filePath, "utf8");
+    const raw = fs18.readFileSync(filePath, "utf8");
     if (raw.length <= maxChars) return raw;
     return `${raw.slice(0, maxChars)}
 
@@ -5344,7 +6144,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path17.join(cwd, name), LIMITS.readme);
+    const c = safeReadFile(path21.join(cwd, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -5352,14 +6152,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd) {
   const paths = [
-    path17.join(cwd, "BluMa.md"),
-    path17.join(cwd, "BLUMA.md"),
-    path17.join(cwd, ".bluma", "BluMa.md")
+    path21.join(cwd, "BluMa.md"),
+    path21.join(cwd, "BLUMA.md"),
+    path21.join(cwd, ".bluma", "BluMa.md")
   ];
   for (const p of paths) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path17.relative(cwd, p) || p;
+      const rel = path21.relative(cwd, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -5367,10 +6167,10 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd) {
-  const p = path17.join(cwd, "package.json");
+  const p = path21.join(cwd, "package.json");
   try {
-    if (!fs15.existsSync(p)) return null;
-    const pkg = JSON.parse(fs15.readFileSync(p, "utf8"));
+    if (!fs18.existsSync(p)) return null;
+    const pkg = JSON.parse(fs18.readFileSync(p, "utf8"));
     const scripts = pkg.scripts;
     let scriptKeys = "";
     if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
@@ -5403,7 +6203,7 @@ function summarizePackageJson(cwd) {
 }
 function topLevelListing(cwd) {
   try {
-    const names = fs15.readdirSync(cwd, { withFileTypes: true });
+    const names = fs18.readdirSync(cwd, { withFileTypes: true });
     const sorted = [...names].sort((a, b) => a.name.localeCompare(b.name));
     const limited = sorted.slice(0, LIMITS.topDirEntries);
     const lines = limited.map((d) => `${d.name}${d.isDirectory() ? "/" : ""}`);
@@ -5461,7 +6261,7 @@ function buildWorkspaceSnapshot(cwd) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path17.join(cwd, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path21.join(cwd, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -5479,15 +6279,15 @@ function buildWorkspaceSnapshot(cwd) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path17.join(cwd, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path21.join(cwd, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path17.join(cwd, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path21.join(cwd, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path17.join(cwd, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path21.join(cwd, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -5550,10 +6350,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs16.existsSync(path18.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs16.existsSync(path18.join(dir, "yarn.lock"))) return "yarn";
-    if (fs16.existsSync(path18.join(dir, "bun.lockb"))) return "bun";
-    if (fs16.existsSync(path18.join(dir, "package-lock.json"))) return "npm";
+    if (fs19.existsSync(path22.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs19.existsSync(path22.join(dir, "yarn.lock"))) return "yarn";
+    if (fs19.existsSync(path22.join(dir, "bun.lockb"))) return "bun";
+    if (fs19.existsSync(path22.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -5561,9 +6361,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs16.readdirSync(dir);
+    const files = fs19.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs16.readFileSync(path18.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs19.readFileSync(path22.join(dir, "package.json"), "utf-8"));
       if (pkg.dependencies?.next || pkg.devDependencies?.next) return "Next.js";
       if (pkg.dependencies?.react || pkg.devDependencies?.react) return "React";
       if (pkg.dependencies?.express || pkg.devDependencies?.express) return "Express";
@@ -5582,9 +6382,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path18.join(dir, "package.json");
-    if (fs16.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path22.join(dir, "package.json");
+    if (fs19.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -5593,7 +6393,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs16.existsSync(path18.join(dir, "pytest.ini")) || fs16.existsSync(path18.join(dir, "conftest.py"))) return "pytest";
+    if (fs19.existsSync(path22.join(dir, "pytest.ini")) || fs19.existsSync(path22.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -5601,9 +6401,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path18.join(dir, "package.json");
-    if (fs16.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path22.join(dir, "package.json");
+    if (fs19.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -5815,6 +6615,12 @@ This is your **long-term scratchpad** (usually \`~/.bluma/coding_memory.json\`).
 5. **Verify** - Check build, lint, and git status
 6. **Summarize** - Report results and any follow-up actions
 
+### For delegated / parallel work:
+1. **Keep the blocking task local** - Do not delegate the very next thing you need.
+2. **Spawn bounded workers** - Use \`spawn_agent\` only for concrete side tasks with a clear output.
+3. **Track workers explicitly** - Use \`wait_agent\` when blocked on a delegated result; use \`list_agents\` to inspect worker state.
+4. **Integrate evidence** - Treat worker results like any other tool output: verify before claiming success.
+
 ### For debugging / incidents (follow \`<engineering_mindset>\`):
 1. **Reproduce** \u2014 run the same command or test the user (or the repo) uses; capture full output via \`command_status\`.
 2. **Localise** \u2014 trace to a specific file/line; read that code with tools before changing anything.
@@ -5844,6 +6650,7 @@ Run tests when modifying code. If a testing skill is listed in available_skills,
 - **For edit_tool**: Provide exact content with correct whitespace (read first!)
 - **Truncated CLI preview** (user may press Ctrl+O for more lines): still not a substitute for \`read_file_lines\` \u2014 use the tool for authoritative content before editing
 - **Check file exists** before attempting edits
+- **Delegate only bounded work** - If you use \`spawn_agent\`, give the worker one concrete subtask and later collect it with \`wait_agent\`
 
 ### Safe Auto-Approved Tools (no confirmation needed):
 - message
@@ -5851,10 +6658,13 @@ Run tests when modifying code. If a testing skill is listed in available_skills,
 - read_file_lines
 - count_file_lines
 - todo
+- wait_agent
+- list_agents
 
 ### Require Confirmation:
 - shell_command (except safe commands)
 - edit_tool (always shows diff preview)
+- spawn_agent (outside sandbox)
 </tool_rules>
 
 ---
@@ -6054,18 +6864,20 @@ You are NOT talking directly to a human; all inputs come from JSON payloads prov
 - ALL outputs must be deterministic, concise and structured for machine parsing.
 - You own this workspace like a senior developer owns their machine: produce, deliver, clean up.
 
-### Execution Capabilities (Python-only)
+### Execution Capabilities (Workspace-first)
 
 You are allowed to:
-- Generate and modify **Python code** (modules, scripts, notebooks, tests).
-- Run **Python commands only**: \`python main.py\`, \`python -m pytest\`, \`python script.py\`, etc.
-- Use the preinstalled Python environment and libraries (pandas, openpyxl, reportlab, etc.).
+- Read, create, edit and overwrite files INSIDE the job workspace.
+- Use \`shell_command\` for non-interactive build, test, conversion and packaging workflows.
+- Use language/toolchain commands that are relevant to the repo or job (Python, Node, npm, bun, uv, pytest, etc.) when they are available in the sandbox image.
+- Fetch exact remote pages with \`web_fetch\` and search external sources with \`search_web\` when the task needs it.
+- Produce deliverables directly inside the workspace and stage final outputs in \`./artifacts/\`.
 
 You are NOT allowed to:
-- Execute arbitrary shell commands (\`bash\`, \`sh\`, \`zsh\`, \`fish\`, \`cmd\`, \`powershell\`).
-- Run system-level tools (\`docker\`, \`npm\`, \`node\`, \`git\`, \`curl\`, \`wget\`, package managers).
-- Change system configuration, users, permissions, or network settings.
-- Use interactive stdin/stdout (\`input()\`, click/typer prompts, curses).
+- Escape the workspace root or assume access to the host machine outside the sandbox.
+- Change host-level system configuration, users, permissions, mounts or network policy.
+- Use interactive terminal applications or flows that require human stdin.
+- Expose secrets, tokens, or environment dumps.
 
 ### File Lifecycle in Sandbox (CRITICAL)
 
@@ -6073,8 +6885,8 @@ You are working in an **isolated job workspace**. Treat it as your personal deve
 Follow this workflow for every task that produces deliverables:
 
 **Step 1 \u2014 Analyse** the request and plan what files you need to generate.
-**Step 2 \u2014 Write a script** (e.g. \`_task_runner.py\`) to produce the deliverables programmatically.
-**Step 3 \u2014 Execute the script** via \`shell_command\` (\`python _task_runner.py\`).
+**Step 2 \u2014 Create or modify workspace files** needed for the job (scripts, templates, configs, source files, etc.).
+**Step 3 \u2014 Execute the workflow** via tools (\`shell_command\`, \`file_write\`, \`edit_tool\`, etc.).
 **Step 4 \u2014 Move or create final documents** inside \`./artifacts/\` directory.
 **Step 5 \u2014 Attach deliverables** \u2014 In your final \`message\` tool call (\`message_type: "result"\`), include the **absolute paths** of every deliverable file in the \`attachments\` array.
 **Step 6 \u2014 Clean up** \u2014 Delete all temporary scripts, intermediate files and working data that are NOT final artifacts.
@@ -6128,9 +6940,9 @@ You MUST treat all environment variables, API keys, tokens and credentials as **
 
 ### Summary
 
-In sandbox mode you are a Python-focused, non-interactive, deterministic agent that:
+In sandbox mode you are a workspace-focused, non-interactive, deterministic agent that:
 1. Analyses the job request.
-2. Writes and executes Python scripts to produce deliverables.
+2. Uses the workspace and tools autonomously to produce deliverables.
 3. Places all final documents in \`./artifacts/\` and lists them in \`attachments[]\`.
 4. Cleans up all temporary files.
 5. NEVER reveals environment variables, secrets, or internal infrastructure details.
@@ -6139,12 +6951,12 @@ In sandbox mode you are a Python-focused, non-interactive, deterministic agent t
 function getUnifiedSystemPrompt(availableSkills) {
   const cwd = process.cwd();
   const env = {
-    os_type: os11.type(),
-    os_version: os11.release(),
-    architecture: os11.arch(),
+    os_type: os13.type(),
+    os_version: os13.release(),
+    architecture: os13.arch(),
     workdir: cwd,
     shell_type: process.env.SHELL || process.env.COMSPEC || "unknown",
-    username: os11.userInfo().username,
+    username: os13.userInfo().username,
     current_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     is_git_repo: isGitRepo(cwd) ? "yes" : "no",
@@ -6333,8 +7145,8 @@ ${memorySnapshot.trim().length > 0 ? memorySnapshot : "(No entries yet. Use codi
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path18.join(dir, ".git");
-    return fs16.existsSync(gitPath) && fs16.lstatSync(gitPath).isDirectory();
+    const gitPath = path22.join(dir, ".git");
+    return fs19.existsSync(gitPath) && fs19.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -6602,7 +7414,7 @@ async function createApiContextWindow(fullHistory, currentAnchor, compressedTurn
 }
 
 // src/app/agent/core/llm/llm.ts
-import os12 from "os";
+import os14 from "os";
 import OpenAI from "openai";
 function defaultBlumaUserContextInput(sessionId, userMessage) {
   const msg = String(userMessage || "").slice(0, 300);
@@ -6619,7 +7431,7 @@ function defaultBlumaUserContextInput(sessionId, userMessage) {
 }
 function getPreferredMacAddress() {
   try {
-    const ifaces = os12.networkInterfaces();
+    const ifaces = os14.networkInterfaces();
     for (const name of Object.keys(ifaces)) {
       const addrs = ifaces[name];
       if (!addrs) continue;
@@ -6634,7 +7446,7 @@ function getPreferredMacAddress() {
   } catch {
   }
   try {
-    return `host:${os12.hostname()}`;
+    return `host:${os14.hostname()}`;
   } catch {
     return "unknown";
   }
@@ -6644,7 +7456,7 @@ function defaultInteractiveCliUserContextInput(sessionId, userMessage) {
   const machineId = getPreferredMacAddress();
   let userName = null;
   try {
-    userName = os12.userInfo().username || null;
+    userName = os14.userInfo().username || null;
   } catch {
     userName = null;
   }
@@ -6971,6 +7783,29 @@ var ToolCallNormalizer = class {
   }
 };
 
+// src/app/agent/runtime/tool_execution_policy.ts
+init_sandbox_policy();
+function decideToolExecution(toolName) {
+  const policy = getSandboxPolicy();
+  const metadata = getNativeToolMetadata(toolName);
+  if (!metadata) {
+    return {
+      toolName,
+      autoApprove: false,
+      requiresConfirmation: true,
+      reason: "Unknown tool metadata; require confirmation by default."
+    };
+  }
+  const autoApprove = policy.isSandbox ? metadata.autoApproveInSandbox : metadata.autoApproveInLocal;
+  return {
+    toolName,
+    metadata,
+    autoApprove,
+    requiresConfirmation: !autoApprove,
+    reason: autoApprove ? policy.isSandbox ? "Tool auto-approved inside workspace sandbox." : "Tool marked safe for local autonomous execution." : "Tool requires confirmation outside sandbox mode."
+  };
+}
+
 // src/app/agent/bluma/core/bluma.ts
 var BluMaAgent = class {
   llm;
@@ -7092,7 +7927,7 @@ var BluMaAgent = class {
     this.isInterrupted = false;
     this.factorRouterTurnClosed = false;
     const inputText = String(userInput.content || "").trim();
-    const turnId = uuidv43();
+    const turnId = uuidv44();
     this.activeTurnContext = {
       ...userContextInput,
       turnId,
@@ -7178,7 +8013,8 @@ var BluMaAgent = class {
         type: "tool_call",
         tool_name: toolName,
         arguments: toolArgs,
-        preview: previewContent
+        preview: previewContent,
+        tool_policy: decideToolExecution(toolName)
       });
       try {
         if (this.isInterrupted) {
@@ -7252,7 +8088,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path19.basename(toolArgs.file_path);
+      const filename = path23.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}`;
@@ -7379,29 +8215,27 @@ ${editData.error.display}`;
         await this._continueConversation();
         return;
       }
-      const isSandbox = process.env.BLUMA_SANDBOX === "true";
-      const autoApprovedTools = [
-        "message",
-        "ls_tool",
-        "count_file_lines",
-        "read_file_lines",
-        "todo",
-        "load_skill",
-        "search_web",
-        "coding_memory"
-      ];
       const toolToCall = validToolCalls[0];
-      const isSafeTool = isSandbox || autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
-      if (isSafeTool) {
+      const decision = decideToolExecution(toolToCall.function.name);
+      if (decision.autoApprove) {
         await this.handleToolResponse({ type: "user_decision_execute", tool_calls: validToolCalls });
       } else {
         const toolName = toolToCall.function.name;
         if (toolName === "edit_tool") {
           const args = JSON.parse(toolToCall.function.arguments);
           const previewContent = await this._generateEditPreview(args);
-          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls, preview: previewContent });
+          this.eventBus.emit("backend_message", {
+            type: "confirmation_request",
+            tool_calls: validToolCalls,
+            preview: previewContent,
+            tool_policy: decision
+          });
         } else {
-          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls });
+          this.eventBus.emit("backend_message", {
+            type: "confirmation_request",
+            tool_calls: validToolCalls,
+            tool_policy: decision
+          });
         }
       }
     } else if (trimmedText) {
@@ -7451,29 +8285,27 @@ ${editData.error.display}`;
         await this._continueConversation();
         return;
       }
-      const isSandbox = process.env.BLUMA_SANDBOX === "true";
-      const autoApprovedTools = [
-        "message",
-        "ls_tool",
-        "count_file_lines",
-        "read_file_lines",
-        "todo",
-        "load_skill",
-        "search_web",
-        "coding_memory"
-      ];
       const toolToCall = validToolCalls[0];
-      const isSafeTool = isSandbox || autoApprovedTools.some((safeTool) => toolToCall.function.name.includes(safeTool));
-      if (isSafeTool) {
+      const decision = decideToolExecution(toolToCall.function.name);
+      if (decision.autoApprove) {
         await this.handleToolResponse({ type: "user_decision_execute", tool_calls: validToolCalls });
       } else {
         const toolName = toolToCall.function.name;
         if (toolName === "edit_tool") {
           const args = JSON.parse(toolToCall.function.arguments);
           const previewContent = await this._generateEditPreview(args);
-          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls, preview: previewContent });
+          this.eventBus.emit("backend_message", {
+            type: "confirmation_request",
+            tool_calls: validToolCalls,
+            preview: previewContent,
+            tool_policy: decision
+          });
         } else {
-          this.eventBus.emit("backend_message", { type: "confirmation_request", tool_calls: validToolCalls });
+          this.eventBus.emit("backend_message", {
+            type: "confirmation_request",
+            tool_calls: validToolCalls,
+            tool_policy: decision
+          });
         }
       }
     } else if (typeof message2.content === "string" && message2.content.trim()) {
@@ -7504,13 +8336,13 @@ function getSubAgentByCommand(cmd) {
 }
 
 // src/app/agent/subagents/init/init_subagent.ts
-import { v4 as uuidv45 } from "uuid";
+import { v4 as uuidv46 } from "uuid";
 
 // src/app/agent/subagents/base_llm_subagent.ts
-import { v4 as uuidv44 } from "uuid";
+import { v4 as uuidv45 } from "uuid";
 
 // src/app/agent/subagents/init/init_system_prompt.ts
-import os13 from "os";
+import os15 from "os";
 var SYSTEM_PROMPT2 = `
 
 ### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -7673,12 +8505,12 @@ Rule Summary:
 function getInitPrompt() {
   const now = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os13.type(),
-    os_version: os13.release(),
-    architecture: os13.arch(),
+    os_type: os15.type(),
+    os_version: os15.release(),
+    architecture: os15.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os13.userInfo().username || "Unknown",
+    username: os15.userInfo().username || "Unknown",
     current_date: now.toISOString().split("T")[0],
     // Formato YYYY-MM-DD
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
@@ -7723,7 +8555,7 @@ var BaseLLMSubAgent = class {
     await this.initializeHistory();
     const rawUser = typeof input === "string" ? input : JSON.stringify(input);
     const base = ctx.blumaUserContextInput ?? defaultBlumaUserContextInput(`subagent:${this.id}`, rawUser.slice(0, 300));
-    const turnId = uuidv44();
+    const turnId = uuidv45();
     this.subagentTurnContext = {
       ...base,
       turnId,
@@ -7784,6 +8616,14 @@ ${editData.error.display}`;
       const message2 = response.choices[0].message;
       this.history.push(message2);
       if (message2.tool_calls) {
+        const decision = decideToolExecution(message2.tool_calls[0].function.name);
+        if (!decision.autoApprove) {
+          this.emitEvent("error", {
+            message: `Subagent tool "${message2.tool_calls[0].function.name}" requires confirmation outside sandbox mode.`
+          });
+          this.emitEvent("done", { status: "blocked_confirmation" });
+          return;
+        }
         await this._handleToolExecution({ type: "user_decision_execute", tool_calls: message2.tool_calls });
         const lastToolName = message2.tool_calls[0].function.name;
         if (!lastToolName.includes("agent_end_turn") && !this.isInterrupted) {
@@ -7822,7 +8662,8 @@ ${editData.error.display}`;
       this.emitEvent("tool_call", {
         tool_name: toolName,
         arguments: toolArgs,
-        preview: previewContent
+        preview: previewContent,
+        tool_policy: decideToolExecution(toolName)
       });
       try {
         if (this.isInterrupted) {
@@ -7856,7 +8697,7 @@ ${editData.error.display}`;
 
 // src/app/agent/subagents/init/init_subagent.ts
 var InitAgentImpl = class extends BaseLLMSubAgent {
-  id = `init_${Date.now()}`;
+  id = "init";
   capabilities = ["/init"];
   async execute(input, ctx) {
     this.ctx = ctx;
@@ -7869,7 +8710,7 @@ var InitAgentImpl = class extends BaseLLMSubAgent {
     const base = ctx.blumaUserContextInput ?? defaultBlumaUserContextInput(`subagent:${this.id}`, preview);
     this.subagentTurnContext = {
       ...base,
-      turnId: uuidv45(),
+      turnId: uuidv46(),
       sessionId: base.sessionId || `subagent:${this.id}`
     };
     const seed = `
@@ -7879,7 +8720,11 @@ var InitAgentImpl = class extends BaseLLMSubAgent {
     Use only evidence gathered via tools; do not invent content. 
     If overwriting an existing BluMa.md is required, follow non-destructive policies and request confirmation as per protocol.
     `;
-    const combined = seed;
+    const initialInput = typeof input === "string" ? input.trim() : JSON.stringify(input ?? "").trim();
+    const combined = initialInput ? `${seed}
+
+User request for init:
+${initialInput}` : seed;
     this.history.push({ role: "user", content: combined });
     await this._continueConversation();
     return { history: this.history };
@@ -7959,14 +8804,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path23, handler) {
-    this.routeHandlers.set(path23, handler);
+  registerRoute(path27, handler) {
+    this.routeHandlers.set(path27, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext } = payload;
-    for (const [path23, handler] of this.routeHandlers) {
-      if (inputText === path23 || inputText.startsWith(`${path23} `)) {
+    for (const [path27, handler] of this.routeHandlers) {
+      if (inputText === path27 || inputText.startsWith(`${path27} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -7975,7 +8820,7 @@ var RouteManager = class {
 };
 
 // src/app/agent/agent.ts
-var globalEnvPath = path20.join(os14.homedir(), ".bluma", ".env");
+var globalEnvPath = path24.join(os16.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -8163,7 +9008,7 @@ var WorkingTimer = memo5(WorkingTimerComponent);
 
 // src/app/ui/components/ToolCallDisplay.tsx
 import { memo as memo6 } from "react";
-import { Box as Box10 } from "ink";
+import { Box as Box10, Text as Text10 } from "ink";
 
 // src/app/ui/components/toolCallRenderers.tsx
 import { Box as Box9, Text as Text9 } from "ink";
@@ -8199,12 +9044,12 @@ var renderShellCommand2 = ({ args }) => {
 };
 var renderLsTool2 = ({ args }) => {
   const parsed = parseArgs(args);
-  const path23 = parsed.directory_path || ".";
+  const path27 = parsed.directory_path || ".";
   return /* @__PURE__ */ jsxs9(Box9, { children: [
     /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "ls" }),
     /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       " ",
-      path23
+      path27
     ] })
   ] });
 };
@@ -8239,6 +9084,22 @@ var renderReadFileLines2 = ({ args }) => {
     ] })
   ] });
 };
+var renderFileWrite = ({ args }) => {
+  const parsed = parseArgs(args);
+  const filepath = parsed.filepath || "[no file]";
+  const content = typeof parsed.content === "string" ? parsed.content : "";
+  const preview = content.split("\n").slice(0, 3).join(" \xB7 ");
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs9(Box9, { children: [
+      /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: "write" }),
+      /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        " ",
+        getBasename(filepath)
+      ] })
+    ] }),
+    preview ? /* @__PURE__ */ jsx9(Box9, { paddingLeft: 2, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: truncate(preview, 80) }) }) : null
+  ] });
+};
 var renderBlumaNotebook = ({ args }) => {
   const parsed = parseArgs(args);
   const thought = parsed.thought || parsed.content?.thought || "[thinking...]";
@@ -8340,7 +9201,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path23 = parsed.path || ".";
+  const path27 = parsed.path || ".";
   return /* @__PURE__ */ jsxs9(Box9, { children: [
     /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "grep" }),
     /* @__PURE__ */ jsxs9(Text9, { color: BLUMA_TERMINAL.brandMagenta, children: [
@@ -8350,7 +9211,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       " ",
-      path23
+      path27
     ] })
   ] });
 };
@@ -8376,6 +9237,54 @@ var renderCommandStatus = ({ args }) => {
     ] })
   ] });
 };
+var renderWebFetch = ({ args }) => {
+  const parsed = parseArgs(args);
+  const url = parsed.url || "[no url]";
+  return /* @__PURE__ */ jsxs9(Box9, { children: [
+    /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "fetch" }),
+    /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+      " ",
+      truncate(url, 70)
+    ] })
+  ] });
+};
+var renderSpawnAgent = ({ args }) => {
+  const parsed = parseArgs(args);
+  const title = parsed.title || parsed.agent_type || "worker";
+  const task = parsed.task || "[no task]";
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs9(Box9, { children: [
+      /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: "spawn" }),
+      /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        " ",
+        title
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx9(Box9, { paddingLeft: 2, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: truncate(String(task), 80) }) })
+  ] });
+};
+var renderWaitAgent = ({ args }) => {
+  const parsed = parseArgs(args);
+  const sessionId = parsed.session_id || "[no session]";
+  return /* @__PURE__ */ jsxs9(Box9, { children: [
+    /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "wait" }),
+    /* @__PURE__ */ jsxs9(Text9, { color: BLUMA_TERMINAL.brandMagenta, children: [
+      " ",
+      truncate(String(sessionId), 18)
+    ] })
+  ] });
+};
+var renderListAgents = ({ args }) => {
+  const parsed = parseArgs(args);
+  const status = parsed.status ? `status=${parsed.status}` : "all";
+  return /* @__PURE__ */ jsxs9(Box9, { children: [
+    /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "agents" }),
+    /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+      " ",
+      status
+    ] })
+  ] });
+};
 var renderTaskBoundary = ({ args }) => {
   const parsed = parseArgs(args);
   const name = parsed.task_name || "[no name]";
@@ -8442,36 +9351,50 @@ var ToolRenderDisplay = {
   read_file_lines: renderReadFileLines2,
   edit_tool: renderEditToolCall,
   todo: renderTodoTool2,
+  file_write: renderFileWrite,
   find_by_name: renderFindByName,
   grep_search: renderGrepSearch,
   view_file_outline: renderViewFileOutline,
   command_status: renderCommandStatus,
+  spawn_agent: renderSpawnAgent,
+  wait_agent: renderWaitAgent,
+  list_agents: renderListAgents,
   task_boundary: renderTaskBoundary,
+  web_fetch: renderWebFetch,
   search_web: renderSearchWeb,
   load_skill: renderLoadSkill
 };
 
 // src/app/ui/components/ToolCallDisplay.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
-var ToolCallDisplayComponent = ({ toolName, args, preview }) => {
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+var ToolCallDisplayComponent = ({ toolName, args, preview, toolPolicy }) => {
   if (toolName.includes("message") || toolName.includes("task_boundary") || toolName === "todo") {
     return null;
   }
   const Renderer = ToolRenderDisplay[toolName] || ((props) => renderGeneric2({ ...props, toolName }));
-  return /* @__PURE__ */ jsx10(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", paddingLeft: 1, children: /* @__PURE__ */ jsx10(Renderer, { toolName, args, preview }) }) });
+  return /* @__PURE__ */ jsx10(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingLeft: 1, children: [
+    toolPolicy?.metadata ? /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+      toolPolicy.metadata.category,
+      " \xB7 ",
+      toolPolicy.metadata.riskLevel,
+      " \xB7 ",
+      toolPolicy.autoApprove ? "auto" : "confirm"
+    ] }) : null,
+    /* @__PURE__ */ jsx10(Renderer, { toolName, args, preview })
+  ] }) });
 };
 var ToolCallDisplay = memo6(ToolCallDisplayComponent);
 
 // src/app/ui/components/ToolResultDisplay.tsx
 import { memo as memo8, useEffect as useEffect5 } from "react";
-import { Box as Box12, Text as Text11 } from "ink";
+import { Box as Box12, Text as Text12 } from "ink";
 
 // src/app/ui/components/MarkdownRenderer.tsx
 import { cloneElement, isValidElement, memo as memo7 } from "react";
-import { Box as Box11, Text as Text10 } from "ink";
+import { Box as Box11, Text as Text11 } from "ink";
 import { marked } from "marked";
 import { highlight } from "cli-highlight";
-import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
 marked.setOptions({ gfm: true });
 function styleInlineNodes(nodes, keyPrefix, style) {
   return nodes.map(
@@ -8503,7 +9426,7 @@ function walkInline(tokens, keyBase, opts = {}) {
       case "text":
         out.push(
           /* @__PURE__ */ jsx11(
-            Text10,
+            Text11,
             {
               bold: opts.bold,
               italic: opts.italic,
@@ -8525,7 +9448,7 @@ function walkInline(tokens, keyBase, opts = {}) {
       case "codespan":
         out.push(
           /* @__PURE__ */ jsx11(
-            Text10,
+            Text11,
             {
               color: opts.link ? BLUMA_TERMINAL.link : BLUMA_TERMINAL.code,
               backgroundColor: opts.link ? void 0 : "black",
@@ -8540,19 +9463,19 @@ function walkInline(tokens, keyBase, opts = {}) {
         const L = t;
         const inner = walkInline(L.tokens, k + "l", { ...opts, link: true });
         out.push(
-          /* @__PURE__ */ jsx11(Box11, { flexDirection: "row", flexWrap: "wrap", children: inner.length > 0 ? inner : /* @__PURE__ */ jsx11(Text10, { color: BLUMA_TERMINAL.link, underline: true, children: L.text }) }, k)
+          /* @__PURE__ */ jsx11(Box11, { flexDirection: "row", flexWrap: "wrap", children: inner.length > 0 ? inner : /* @__PURE__ */ jsx11(Text11, { color: BLUMA_TERMINAL.link, underline: true, children: L.text }) }, k)
         );
         break;
       }
       case "br":
         out.push(
-          /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "\n" }, k)
+          /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "\n" }, k)
         );
         break;
       case "escape":
         out.push(
           /* @__PURE__ */ jsx11(
-            Text10,
+            Text11,
             {
               bold: opts.bold,
               italic: opts.italic,
@@ -8570,7 +9493,7 @@ function walkInline(tokens, keyBase, opts = {}) {
       case "image": {
         const Im = t;
         out.push(
-          /* @__PURE__ */ jsxs10(Text10, { dimColor: true, italic: true, children: [
+          /* @__PURE__ */ jsxs11(Text11, { dimColor: true, italic: true, children: [
             "[",
             Im.text || "img",
             "]"
@@ -8581,7 +9504,7 @@ function walkInline(tokens, keyBase, opts = {}) {
       default:
         if ("text" in t && typeof t.text === "string") {
           out.push(
-            /* @__PURE__ */ jsx11(Text10, { bold: opts.bold, italic: opts.italic, children: t.text }, k)
+            /* @__PURE__ */ jsx11(Text11, { bold: opts.bold, italic: opts.italic, children: t.text }, k)
           );
         }
     }
@@ -8590,7 +9513,7 @@ function walkInline(tokens, keyBase, opts = {}) {
 }
 function renderParagraph(p, key) {
   const nodes = walkInline(p.tokens, key);
-  return /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, flexDirection: "row", flexWrap: "wrap", children: nodes.length > 0 ? nodes : /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: p.text }) }, key);
+  return /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, flexDirection: "row", flexWrap: "wrap", children: nodes.length > 0 ? nodes : /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: p.text }) }, key);
 }
 function renderListItemBlocks(item, depth, keyBase) {
   if (!item.tokens?.length) {
@@ -8626,15 +9549,15 @@ function renderListBlock(list, depth, keyBase) {
     );
     const gColor = depth === 0 ? BLUMA_TERMINAL.listBullet : BLUMA_TERMINAL.listBulletSub;
     const body = renderListItemBlocks(item, depth, `${keyBase}-it${idx}`);
-    return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "row", alignItems: "flex-start", marginBottom: 0, children: [
-      /* @__PURE__ */ jsx11(Text10, { color: gColor, children: (item.task ? glyph : `${glyph} `).padEnd(item.task ? 4 : 3, " ") }),
-      /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", flexGrow: 1, children: body.length > 0 ? body : /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: item.text }) })
+    return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "row", alignItems: "flex-start", marginBottom: 0, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: gColor, children: (item.task ? glyph : `${glyph} `).padEnd(item.task ? 4 : 3, " ") }),
+      /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", flexGrow: 1, children: body.length > 0 ? body : /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: item.text }) })
     ] }, `${keyBase}-row-${idx}`);
   }) }, keyBase);
 }
 function renderBlockquote(q, key) {
-  const inner = q.tokens && q.tokens.length > 0 ? renderBlockTokens(q.tokens, `${key}-inner`) : /* @__PURE__ */ jsx11(Text10, { dimColor: true, italic: true, children: q.text });
-  return /* @__PURE__ */ jsxs10(
+  const inner = q.tokens && q.tokens.length > 0 ? renderBlockTokens(q.tokens, `${key}-inner`) : /* @__PURE__ */ jsx11(Text11, { dimColor: true, italic: true, children: q.text });
+  return /* @__PURE__ */ jsxs11(
     Box11,
     {
       flexDirection: "row",
@@ -8644,7 +9567,7 @@ function renderBlockquote(q, key) {
       paddingLeft: 1,
       paddingY: 0,
       children: [
-        /* @__PURE__ */ jsx11(Text10, { color: BLUMA_TERMINAL.brandMagenta, children: "\u2502 " }),
+        /* @__PURE__ */ jsx11(Text11, { color: BLUMA_TERMINAL.brandMagenta, children: "\u2502 " }),
         /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", flexGrow: 1, children: inner })
       ]
     },
@@ -8663,9 +9586,9 @@ function renderBlockTokens(tokens, keyRoot) {
         const prefix = h.depth <= 2 ? `${"#".repeat(h.depth)} ` : "";
         const inner = walkInline(h.tokens, `${key}-h`);
         elements.push(
-          /* @__PURE__ */ jsxs10(Box11, { marginBottom: 1, flexDirection: "row", flexWrap: "wrap", alignItems: "flex-start", children: [
-            /* @__PURE__ */ jsx11(Text10, { color, bold: true, children: prefix }),
-            inner.length > 0 ? inner : /* @__PURE__ */ jsx11(Text10, { color, bold: true, children: h.text })
+          /* @__PURE__ */ jsxs11(Box11, { marginBottom: 1, flexDirection: "row", flexWrap: "wrap", alignItems: "flex-start", children: [
+            /* @__PURE__ */ jsx11(Text11, { color, bold: true, children: prefix }),
+            inner.length > 0 ? inner : /* @__PURE__ */ jsx11(Text11, { color, bold: true, children: h.text })
           ] }, key)
         );
         break;
@@ -8688,7 +9611,7 @@ function renderBlockTokens(tokens, keyRoot) {
           highlighted = code.text;
         }
         elements.push(
-          /* @__PURE__ */ jsxs10(
+          /* @__PURE__ */ jsxs11(
             Box11,
             {
               flexDirection: "column",
@@ -8697,8 +9620,8 @@ function renderBlockTokens(tokens, keyRoot) {
               borderColor: BLUMA_TERMINAL.panelBorder,
               paddingX: 1,
               children: [
-                code.lang ? /* @__PURE__ */ jsx11(Text10, { color: BLUMA_TERMINAL.codeLabel, dimColor: true, children: code.lang }) : null,
-                /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: highlighted })
+                code.lang ? /* @__PURE__ */ jsx11(Text11, { color: BLUMA_TERMINAL.codeLabel, dimColor: true, children: code.lang }) : null,
+                /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: highlighted })
               ]
             },
             key
@@ -8712,15 +9635,15 @@ function renderBlockTokens(tokens, keyRoot) {
       case "table": {
         const table = token;
         elements.push(
-          /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", marginBottom: 1, children: [
+          /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginBottom: 1, children: [
             /* @__PURE__ */ jsx11(Box11, { flexDirection: "row", children: table.header.map((cell, idx) => {
               const headerNodes = walkInline(cell.tokens, `${key}-h${idx}`);
-              const styled = headerNodes.length > 0 ? styleInlineNodes(headerNodes, `${key}-h${idx}`, { bold: true, color: BLUMA_TERMINAL.brandBlue }) : [/* @__PURE__ */ jsx11(Text10, { bold: true, color: BLUMA_TERMINAL.brandBlue, children: cell.text }, `${key}-h${idx}-t`)];
+              const styled = headerNodes.length > 0 ? styleInlineNodes(headerNodes, `${key}-h${idx}`, { bold: true, color: BLUMA_TERMINAL.brandBlue }) : [/* @__PURE__ */ jsx11(Text11, { bold: true, color: BLUMA_TERMINAL.brandBlue, children: cell.text }, `${key}-h${idx}-t`)];
               return /* @__PURE__ */ jsx11(Box11, { paddingRight: 2, flexDirection: "row", flexWrap: "wrap", children: styled }, idx);
             }) }),
             table.rows.map((row, rowIdx) => /* @__PURE__ */ jsx11(Box11, { flexDirection: "row", children: row.map((cell, cellIdx) => {
               const cellNodes = walkInline(cell.tokens, `${key}-c${rowIdx}-${cellIdx}`);
-              const styled = cellNodes.length > 0 ? styleInlineNodes(cellNodes, `${key}-c${rowIdx}-${cellIdx}`, { dimColor: true }) : [/* @__PURE__ */ jsx11(Text10, { dimColor: true, children: cell.text }, `${key}-c${rowIdx}-${cellIdx}-t`)];
+              const styled = cellNodes.length > 0 ? styleInlineNodes(cellNodes, `${key}-c${rowIdx}-${cellIdx}`, { dimColor: true }) : [/* @__PURE__ */ jsx11(Text11, { dimColor: true, children: cell.text }, `${key}-c${rowIdx}-${cellIdx}-t`)];
               return /* @__PURE__ */ jsx11(Box11, { paddingRight: 2, flexDirection: "row", flexWrap: "wrap", children: styled }, cellIdx);
             }) }, `${key}-r${rowIdx}`))
           ] }, key)
@@ -8729,7 +9652,7 @@ function renderBlockTokens(tokens, keyRoot) {
       }
       case "hr":
         elements.push(
-          /* @__PURE__ */ jsx11(Box11, { marginY: 1, children: /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "\u2500".repeat(42) }) }, key)
+          /* @__PURE__ */ jsx11(Box11, { marginY: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "\u2500".repeat(42) }) }, key)
         );
         break;
       case "space":
@@ -8737,7 +9660,7 @@ function renderBlockTokens(tokens, keyRoot) {
       default:
         if ("text" in token && typeof token.text === "string") {
           elements.push(
-            /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: token.text }, key)
+            /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: token.text }, key)
           );
         }
     }
@@ -8824,7 +9747,7 @@ function peekLatestExpandable() {
 }
 
 // src/app/ui/components/ToolResultDisplay.tsx
-import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
 var parseResult2 = (result) => {
   try {
     return JSON.parse(result);
@@ -8846,29 +9769,111 @@ function TodoTaskLine({
   done,
   label
 }) {
-  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsx12(Text11, { color: done ? BLUMA_TERMINAL.brandBlue : BLUMA_TERMINAL.brandMagenta, children: done ? "\u25A0 " : "\u25A1 " }),
-    /* @__PURE__ */ jsx12(Text11, { dimColor: done, strikethrough: done, color: done ? BLUMA_TERMINAL.muted : void 0, children: label })
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx12(Text12, { color: done ? BLUMA_TERMINAL.brandBlue : BLUMA_TERMINAL.brandMagenta, children: done ? "\u25A0 " : "\u25A1 " }),
+    /* @__PURE__ */ jsx12(Text12, { dimColor: done, strikethrough: done, color: done ? BLUMA_TERMINAL.muted : void 0, children: label })
   ] });
 }
 var ToolResultDisplayComponent = ({ toolName, result }) => {
   useEffect5(() => {
     refreshExpandableFromToolResult(toolName, result);
   }, [toolName, result]);
-  if (toolName.includes("task_boundary")) {
-    return null;
-  }
   const parsed = parseResult2(result);
+  if (toolName.includes("task_boundary") && parsed) {
+    const activeTask = parsed.activeTask;
+    const stats = parsed.stats;
+    const msg = typeof parsed.message === "string" ? parsed.message : "";
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      msg ? /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: msg }) : null,
+      activeTask ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        String(activeTask.mode || "EXECUTION"),
+        " \xB7 ",
+        String(activeTask.taskName || ""),
+        activeTask.status ? ` \xB7 ${String(activeTask.status)}` : ""
+      ] }) : null,
+      stats ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        String(stats.completed ?? 0),
+        "/",
+        String(stats.total ?? 0),
+        " done \xB7 ",
+        String(stats.progress ?? 0),
+        "%"
+      ] }) : null
+    ] }) });
+  }
   if (toolName.includes("message")) {
     const body = parsed?.content?.body ?? parsed?.body ?? parsed?.message;
     if (!body) return null;
     return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, flexDirection: "column", children: /* @__PURE__ */ jsx12(MarkdownRenderer, { markdown: String(body) }) }) });
   }
+  if (toolName.includes("file_write") && parsed) {
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        parsed.created ? "created" : "updated",
+        " ",
+        String(parsed.filepath || "")
+      ] }),
+      parsed.bytes_written != null ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        String(parsed.bytes_written),
+        " bytes"
+      ] }) : null
+    ] }) });
+  }
+  if (toolName.includes("spawn_agent") && parsed) {
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        String(parsed.title || "worker"),
+        " \xB7 ",
+        String(parsed.session_id || "")
+      ] }),
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        "status ",
+        String(parsed.status || "running"),
+        parsed.pid != null ? ` \xB7 pid ${String(parsed.pid)}` : ""
+      ] })
+    ] }) });
+  }
+  if (toolName.includes("wait_agent") && parsed) {
+    const session = parsed.session || {};
+    const resultStatus = parsed.result?.status;
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        String(session.session_id || ""),
+        " \xB7 ",
+        String(session.status || "")
+      ] }),
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        parsed.completed ? "completed" : "still running",
+        resultStatus ? ` \xB7 result ${String(resultStatus)}` : ""
+      ] })
+    ] }) });
+  }
+  if (toolName.includes("list_agents") && parsed) {
+    const agents = Array.isArray(parsed.agents) ? parsed.agents : [];
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        String(parsed.count || agents.length),
+        " agents"
+      ] }),
+      agents.slice(0, 5).map((agent, i) => {
+        const row = agent;
+        return /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+          String(row.session_id || ""),
+          " \xB7 ",
+          String(row.status || "")
+        ] }, i);
+      }),
+      agents.length > 5 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        "\u2026 +",
+        agents.length - 5
+      ] }) : null
+    ] }) });
+  }
   if (toolName.includes("read_file") && parsed && typeof parsed.content === "string") {
     const { lines, truncated } = truncateLines(parsed.content, TOOL_PREVIEW_MAX_LINES);
-    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", paddingLeft: 2, children: [
-      lines.map((line, i) => /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: line.slice(0, 120) }, i)),
-      truncated > 0 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      lines.map((line, i) => /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: line.slice(0, 120) }, i)),
+      truncated > 0 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         "\u2026 +",
         truncated,
         " lines \xB7 Ctrl+O expand"
@@ -8881,27 +9886,27 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
     const exitCode = parsed.exit_code ?? parsed.exitCode ?? 0;
     const status = String(parsed.status || "");
     if (parsed.command_id && !output && !stderr && !status) {
-      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         "started #",
         String(parsed.command_id).slice(0, 8)
       ] }) }) });
     }
     if (status === "running") {
-      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsx12(Text11, { color: BLUMA_TERMINAL.warn, dimColor: true, children: "still running\u2026" }) }) });
+      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsx12(Text12, { color: BLUMA_TERMINAL.warn, dimColor: true, children: "still running\u2026" }) }) });
     }
     if (!output && !stderr) return null;
     const { lines, truncated } = truncateLines(output || stderr, TOOL_PREVIEW_MAX_LINES);
     const isError = exitCode !== 0;
     const isSuccess = exitCode === 0 && status !== "running";
     const lineColor = isError ? BLUMA_TERMINAL.err : isSuccess ? BLUMA_TERMINAL.success : BLUMA_TERMINAL.muted;
-    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", paddingLeft: 2, children: [
-      lines.map((line, i) => /* @__PURE__ */ jsx12(Text11, { dimColor: true, color: lineColor, children: line.slice(0, 120) }, i)),
-      truncated > 0 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      lines.map((line, i) => /* @__PURE__ */ jsx12(Text12, { dimColor: true, color: lineColor, children: line.slice(0, 120) }, i)),
+      truncated > 0 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         "\u2026 +",
         truncated,
         " lines \xB7 Ctrl+O expand"
       ] }) : null,
-      exitCode !== 0 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, color: BLUMA_TERMINAL.err, children: [
+      exitCode !== 0 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, color: BLUMA_TERMINAL.err, children: [
         "exit ",
         exitCode
       ] }) : null
@@ -8910,23 +9915,23 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
   if ((toolName.includes("grep") || toolName.includes("find_by_name")) && parsed) {
     const matches = parsed.matches || parsed.results || parsed.files || [];
     if (matches.length === 0) {
-      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "no matches" }) }) });
+      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "no matches" }) }) });
     }
-    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", paddingLeft: 2, children: [
-      /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         matches.length,
         " matches"
       ] }),
       matches.slice(0, 5).map((m, i) => {
         const row = m;
-        const path23 = row.file || row.path || row.name || m;
+        const path27 = row.file || row.path || row.name || m;
         const line = row.line;
-        return /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
-          String(path23),
+        return /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+          String(path27),
           line != null ? `:${line}` : ""
         ] }, i);
       }),
-      matches.length > 5 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+      matches.length > 5 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         "\u2026 +",
         matches.length - 5
       ] }) : null
@@ -8935,17 +9940,17 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
   if (toolName.includes("ls_tool") && parsed) {
     const entries = parsed.entries || parsed.files || [];
     if (entries.length === 0) return null;
-    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
       entries.slice(0, 6).map((e, i) => {
         const row = e;
         const name = row.name ?? e;
         const isDir = Boolean(row.isDirectory);
-        return /* @__PURE__ */ jsxs11(Text11, { dimColor: true, color: isDir ? BLUMA_TERMINAL.brandBlue : BLUMA_TERMINAL.muted, children: [
+        return /* @__PURE__ */ jsxs12(Text12, { dimColor: true, color: isDir ? BLUMA_TERMINAL.brandBlue : BLUMA_TERMINAL.muted, children: [
           isDir ? "d " : "f ",
           String(name)
         ] }, i);
       }),
-      entries.length > 6 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+      entries.length > 6 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         "\u2026 +",
         entries.length - 6
       ] }) : null
@@ -8953,15 +9958,15 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
   }
   if (toolName.includes("load_skill") && parsed) {
     if (!parsed.success) {
-      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsxs11(Text11, { dimColor: true, color: BLUMA_TERMINAL.err, children: [
+      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { paddingLeft: 2, children: /* @__PURE__ */ jsxs12(Text12, { dimColor: true, color: BLUMA_TERMINAL.err, children: [
         "Not found: ",
         String(parsed.message || "")
       ] }) }) });
     }
     const desc = parsed.description ? String(parsed.description) : "";
-    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Box12, { paddingLeft: 2, flexDirection: "row", flexWrap: "wrap", children: [
-      /* @__PURE__ */ jsx12(Text11, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: String(parsed.skill_name || "") }),
-      /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { paddingLeft: 2, flexDirection: "row", flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsx12(Text12, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: String(parsed.skill_name || "") }),
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         " ",
         "\u2014 ",
         desc.slice(0, 80),
@@ -8969,14 +9974,27 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
       ] })
     ] }) });
   }
+  if (toolName.includes("web_fetch") && parsed) {
+    const content = typeof parsed.content === "string" ? parsed.content : "";
+    const { lines, truncated } = truncateLines(content, TOOL_PREVIEW_MAX_LINES);
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        String(parsed.status_code ?? ""),
+        " \xB7 ",
+        String(parsed.content_type ?? "")
+      ] }),
+      lines.map((line, i) => /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: line.slice(0, 120) }, i)),
+      truncated > 0 || parsed.truncated ? /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "\u2026 Ctrl+O expand" }) : null
+    ] }) });
+  }
   if (toolName.includes("todo")) {
     if (parsed && Array.isArray(parsed.tasks)) {
       const tasks = parsed.tasks;
       const stats = parsed.stats;
       const msg = typeof parsed.message === "string" ? parsed.message : "";
-      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", paddingLeft: 2, children: [
-        msg ? /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: msg }) }) : null,
-        stats && typeof stats.progress === "number" ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+      return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+        msg ? /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: msg }) }) : null,
+        stats && typeof stats.progress === "number" ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
           stats.completed ?? 0,
           "/",
           stats.total ?? tasks.length,
@@ -8984,13 +10002,18 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
           stats.progress,
           "%"
         ] }) : null,
-        /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", marginTop: 1, children: [
+          parsed.activeTask ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+            String(parsed.activeTask.mode || "EXECUTION"),
+            " \xB7 ",
+            String(parsed.activeTask.taskName || "")
+          ] }) : null,
           tasks.slice(0, 12).map((t, i) => {
             const done = t.status === "completed" || t.isComplete === true;
             const line = `#${t.id ?? i + 1} ${t.description ?? ""}`;
             return /* @__PURE__ */ jsx12(TodoTaskLine, { done, label: line }, i);
           }),
-          tasks.length > 12 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+          tasks.length > 12 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
             "\u2026 +",
             tasks.length - 12,
             " tasks"
@@ -9000,21 +10023,21 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
     }
     const lines = result.split("\n").filter(Boolean);
     if (lines.length === 0) return null;
-    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", paddingLeft: 2, children: lines.slice(0, 14).map((line, i) => /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: line.slice(0, 100) }, i)) }) });
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", paddingLeft: 2, children: lines.slice(0, 14).map((line, i) => /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: line.slice(0, 100) }, i)) }) });
   }
   if (toolName.includes("view_file_outline") && parsed) {
     const symbols = parsed.symbols || parsed.outline || [];
     if (symbols.length === 0) return null;
-    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", paddingLeft: 2, children: [
+    return /* @__PURE__ */ jsx12(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingLeft: 2, children: [
       symbols.slice(0, 5).map((s, i) => {
         const row = s;
-        return /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+        return /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
           String(row.kind || "sym"),
           " ",
           String(row.name || "")
         ] }, i);
       }),
-      symbols.length > 5 ? /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+      symbols.length > 5 ? /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
         "\u2026 +",
         symbols.length - 5
       ] }) : null
@@ -9025,35 +10048,35 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
 var ToolResultDisplay = memo8(ToolResultDisplayComponent);
 
 // src/app/ui/SessionInfoConnectingMCP.tsx
-import { Box as Box13, Text as Text12 } from "ink";
+import { Box as Box13, Text as Text13 } from "ink";
 import Spinner from "ink-spinner";
-import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
 var SessionInfoConnectingMCP = ({
   workdir,
   statusMessage
-}) => /* @__PURE__ */ jsx13(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", paddingLeft: 1, children: [
-  /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
-    /* @__PURE__ */ jsx13(Text12, { color: BLUMA_TERMINAL.brandMagenta, children: "\u2514 " }),
+}) => /* @__PURE__ */ jsx13(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", paddingLeft: 1, children: [
+  /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+    /* @__PURE__ */ jsx13(Text13, { color: BLUMA_TERMINAL.brandMagenta, children: "\u2514 " }),
     workdir
   ] }),
-  /* @__PURE__ */ jsxs12(Box13, { marginTop: 1, flexDirection: "row", flexWrap: "wrap", children: [
-    /* @__PURE__ */ jsxs12(Text12, { color: BLUMA_TERMINAL.warn, children: [
+  /* @__PURE__ */ jsxs13(Box13, { marginTop: 1, flexDirection: "row", flexWrap: "wrap", children: [
+    /* @__PURE__ */ jsxs13(Text13, { color: BLUMA_TERMINAL.warn, children: [
       /* @__PURE__ */ jsx13(Spinner, { type: "dots" }),
       " "
     ] }),
-    /* @__PURE__ */ jsx13(Text12, { dimColor: true, children: statusMessage || "Establishing MCP\u2026" })
+    /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: statusMessage || "Establishing MCP\u2026" })
   ] })
 ] }) });
 var SessionInfoConnectingMCP_default = SessionInfoConnectingMCP;
 
 // src/app/ui/components/SlashCommands.tsx
-import { Box as Box14, Text as Text13 } from "ink";
+import { Box as Box14, Text as Text14 } from "ink";
 
 // src/app/ui/constants/historyLayout.ts
 var HEADER_PANEL_HISTORY_ID = 0;
 
 // src/app/ui/components/SlashCommands.tsx
-import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
 var SlashCommands = ({
   input,
   setHistory,
@@ -9069,13 +10092,13 @@ var SlashCommands = ({
     if (cmd === "help") {
       const lines = formatSlashHelpLines();
       return outBox(
-        /* @__PURE__ */ jsxs13(Fragment2, { children: [
-          /* @__PURE__ */ jsxs13(Box14, { marginBottom: 1, children: [
-            /* @__PURE__ */ jsx14(Text13, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "Slash commands" }),
-            /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: " \xB7 " }),
-            /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: "put .png/.jpg/.webp paths in a normal message to attach images (project dir or ~)" })
+        /* @__PURE__ */ jsxs14(Fragment2, { children: [
+          /* @__PURE__ */ jsxs14(Box14, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx14(Text14, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "Slash commands" }),
+            /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: " \xB7 " }),
+            /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "put .png/.jpg/.webp paths in a normal message to attach images (project dir or ~)" })
           ] }),
-          /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx14(Text13, { dimColor: line.trim().length > 0, children: line || " " }, i)) })
+          /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx14(Text14, { dimColor: line.trim().length > 0, children: line || " " }, i)) })
         ] })
       );
     }
@@ -9083,32 +10106,32 @@ var SlashCommands = ({
       const list = agentRef.current?.listAvailableSkills?.() || [];
       const dirs = agentRef.current?.getSkillsDirs?.();
       return outBox(
-        /* @__PURE__ */ jsxs13(Fragment2, { children: [
-          /* @__PURE__ */ jsxs13(Box14, { marginBottom: 1, children: [
-            /* @__PURE__ */ jsx14(Text13, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "Skills (load_skill)" }),
-            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+        /* @__PURE__ */ jsxs14(Fragment2, { children: [
+          /* @__PURE__ */ jsxs14(Box14, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx14(Text14, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "Skills (load_skill)" }),
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
               " \xB7 ",
               list.length,
               " available"
             ] })
           ] }),
-          dirs ? /* @__PURE__ */ jsxs13(Box14, { marginBottom: 1, flexDirection: "column", children: [
-            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+          dirs ? /* @__PURE__ */ jsxs14(Box14, { marginBottom: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
               "bundled: ",
               String(dirs.bundled || "")
             ] }),
-            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
               "project: ",
               String(dirs.project || "")
             ] }),
-            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
               "global: ",
               String(dirs.global || "")
             ] })
           ] }) : null,
-          list.length === 0 ? /* @__PURE__ */ jsx14(Text13, { color: "yellow", children: "No skills found (check bundled dist/config/skills)." }) : /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", children: list.map((s, i) => /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", marginBottom: 1, children: [
-            /* @__PURE__ */ jsx14(Text13, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: s.name }),
-            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+          list.length === 0 ? /* @__PURE__ */ jsx14(Text14, { color: "yellow", children: "No skills found (check bundled dist/config/skills)." }) : /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", children: list.map((s, i) => /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", marginBottom: 1, children: [
+            /* @__PURE__ */ jsx14(Text14, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: s.name }),
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
               s.source,
               " \u2014 ",
               s.description || "\u2014"
@@ -9121,9 +10144,9 @@ var SlashCommands = ({
       onClearRecent?.();
       setHistory((prev) => prev.filter((item) => item.id === HEADER_PANEL_HISTORY_ID));
       return outBox(
-        /* @__PURE__ */ jsxs13(Box14, { children: [
-          /* @__PURE__ */ jsx14(Text13, { color: "green", children: "[ok]" }),
-          /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: " History cleared" })
+        /* @__PURE__ */ jsxs14(Box14, { children: [
+          /* @__PURE__ */ jsx14(Text14, { color: "green", children: "[ok]" }),
+          /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: " History cleared" })
         ] })
       );
     }
@@ -9135,7 +10158,7 @@ var SlashCommands = ({
           setHistory((prev) => prev.concat({
             id: Date.now(),
             component: outBox(
-              /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs13(Text13, { color: "red", children: [
+              /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs14(Text14, { color: "red", children: [
                 "Failed to execute /init: ",
                 e?.message || String(e)
               ] }) })
@@ -9156,41 +10179,41 @@ var SlashCommands = ({
       const colType = 10;
       const colSource = 18;
       return outBox(
-        /* @__PURE__ */ jsxs13(Fragment2, { children: [
-          /* @__PURE__ */ jsxs13(Box14, { marginBottom: 1, children: [
-            /* @__PURE__ */ jsx14(Text13, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "MCP Tools" }),
-            /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: " \u2022 " }),
-            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+        /* @__PURE__ */ jsxs14(Fragment2, { children: [
+          /* @__PURE__ */ jsxs14(Box14, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx14(Text14, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "MCP Tools" }),
+            /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: " \u2022 " }),
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
               tools.length,
               " total"
             ] }),
-            term && /* @__PURE__ */ jsxs13(Fragment2, { children: [
-              /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: " \u2022 filter: " }),
-              /* @__PURE__ */ jsxs13(Text13, { color: BLUMA_TERMINAL.brandBlue, children: [
+            term && /* @__PURE__ */ jsxs14(Fragment2, { children: [
+              /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: " \u2022 filter: " }),
+              /* @__PURE__ */ jsxs14(Text14, { color: BLUMA_TERMINAL.brandBlue, children: [
                 '"',
                 term,
                 '"'
               ] }),
-              /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
                 " \u2022 showing: ",
                 filtered.length
               ] })
             ] })
           ] }),
-          filtered.length === 0 ? /* @__PURE__ */ jsx14(Text13, { color: "yellow", children: "No MCP tools found" }) : /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+          filtered.length === 0 ? /* @__PURE__ */ jsx14(Text14, { color: "yellow", children: "No MCP tools found" }) : /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs14(Text14, { color: "gray", children: [
               pad("Name", colName),
               " \u2502 ",
               pad("Type", colType),
               " \u2502 ",
               pad("Source", colSource)
             ] }) }),
-            /* @__PURE__ */ jsx14(Text13, { color: "gray", children: "\u2500".repeat(colName + colType + colSource + 6) }),
+            /* @__PURE__ */ jsx14(Text14, { color: "gray", children: "\u2500".repeat(colName + colType + colSource + 6) }),
             filtered.map((t, i) => {
               const name = t.function?.name || t.name || "tool";
               const type = t.function?.name ? "fn" : t.type || "tool";
               const source = t.source || t.provider || "mcp";
-              return /* @__PURE__ */ jsxs13(Text13, { color: "white", children: [
+              return /* @__PURE__ */ jsxs14(Text14, { color: "white", children: [
                 pad(name, colName),
                 " \u2502 ",
                 pad(String(type), colType),
@@ -9213,22 +10236,22 @@ var SlashCommands = ({
       const colType = 10;
       const colSource = 18;
       return outBox(
-        /* @__PURE__ */ jsxs13(Fragment2, { children: [
-          /* @__PURE__ */ jsx14(Text13, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: "Native Tools" }),
-          /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+        /* @__PURE__ */ jsxs14(Fragment2, { children: [
+          /* @__PURE__ */ jsx14(Text14, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: "Native Tools" }),
+          /* @__PURE__ */ jsxs14(Text14, { color: "gray", children: [
             "Total Native: ",
             tools.length,
             term ? `  |  Filter: "${term}"  |  Showing: ${filtered.length}` : ""
           ] }),
-          filtered.length === 0 ? /* @__PURE__ */ jsx14(Text13, { color: "yellow", children: "No native tools to display." }) : /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+          filtered.length === 0 ? /* @__PURE__ */ jsx14(Text14, { color: "yellow", children: "No native tools to display." }) : /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs14(Text14, { color: "gray", children: [
               pad("Name", colName),
               " | ",
               pad("Type", colType),
               " | ",
               pad("Source", colSource)
             ] }),
-            /* @__PURE__ */ jsxs13(Text13, { color: "gray", children: [
+            /* @__PURE__ */ jsxs14(Text14, { color: "gray", children: [
               "".padEnd(colName, "-"),
               "---",
               "".padEnd(colType, "-"),
@@ -9239,7 +10262,7 @@ var SlashCommands = ({
               const name = t.function?.name || t.name || "tool";
               const type = t.function?.name ? "fn" : t.type || "tool";
               const source = t.source || "native";
-              return /* @__PURE__ */ jsxs13(Text13, { color: "white", children: [
+              return /* @__PURE__ */ jsxs14(Text14, { color: "white", children: [
                 pad(name, colName),
                 " | ",
                 pad(String(type), colType),
@@ -9251,7 +10274,7 @@ var SlashCommands = ({
         ] })
       );
     }
-    return outBox(/* @__PURE__ */ jsxs13(Text13, { color: "red", children: [
+    return outBox(/* @__PURE__ */ jsxs14(Text14, { color: "red", children: [
       "Command not recognized: /",
       cmd
     ] }));
@@ -9265,16 +10288,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import path21 from "path";
-import fs17 from "fs";
+import path25 from "path";
+import fs20 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 = path21.join(dir, "package.json");
-    if (fs17.existsSync(candidate)) {
+    const candidate = path25.join(dir, "package.json");
+    if (fs20.existsSync(candidate)) {
       try {
-        const raw = fs17.readFileSync(candidate, "utf8");
+        const raw = fs20.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -9282,7 +10305,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path21.dirname(dir);
+    const parent = path25.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -9291,13 +10314,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path21.resolve(dir);
+    const abs = path25.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path21.dirname(fileURLToPath4(import.meta.url)));
+    const fromBundle = tryFrom(path25.dirname(fileURLToPath4(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -9305,12 +10328,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path21.isAbsolute(argv1) && fs17.existsSync(argv1)) {
-        resolved = fs17.realpathSync(argv1);
+      if (path25.isAbsolute(argv1) && fs20.existsSync(argv1)) {
+        resolved = fs20.realpathSync(argv1);
       } else {
-        resolved = path21.resolve(process.cwd(), argv1);
+        resolved = path25.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path21.dirname(resolved));
+      const fromArgv = tryFrom(path25.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -9354,8 +10377,8 @@ Run: npm i -g ${BLUMA_PACKAGE_NAME} to update.`;
 }
 
 // src/app/ui/components/UpdateNotice.tsx
-import { Box as Box15, Text as Text14 } from "ink";
-import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
+import { Box as Box15, Text as Text15 } from "ink";
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
 function parseUpdateMessage(msg) {
   const lines = msg.split(/\r?\n/).map((l) => l.trim());
   const first = lines[0] || "";
@@ -9371,25 +10394,25 @@ function parseUpdateMessage(msg) {
 }
 var UpdateNotice = ({ message: message2 }) => {
   const { name, current, latest: latest2, hint } = parseUpdateMessage(message2);
-  return /* @__PURE__ */ jsx15(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", paddingLeft: 2, children: [
-    name && current && latest2 ? /* @__PURE__ */ jsx15(Text14, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: name }) : null,
-    name && current && latest2 ? /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+  return /* @__PURE__ */ jsx15(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", paddingLeft: 2, children: [
+    name && current && latest2 ? /* @__PURE__ */ jsx15(Text15, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: name }) : null,
+    name && current && latest2 ? /* @__PURE__ */ jsxs15(Text15, { dimColor: true, children: [
       current,
       " \u2192 ",
       latest2
-    ] }) : /* @__PURE__ */ jsx15(Text14, { dimColor: true, children: message2 }),
-    hint ? /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text14, { dimColor: true, children: hint }) }) : null
+    ] }) : /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: message2 }),
+    hint ? /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: hint }) }) : null
   ] }) });
 };
 var UpdateNotice_default = UpdateNotice;
 
 // src/app/ui/components/ErrorMessage.tsx
-import { Box as Box16, Text as Text15 } from "ink";
-import { jsx as jsx16, jsxs as jsxs15 } from "react/jsx-runtime";
-var ErrorMessage = ({ message: message2, details, hint }) => /* @__PURE__ */ jsx16(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", paddingLeft: 2, children: [
-  /* @__PURE__ */ jsx16(Text15, { color: BLUMA_TERMINAL.err, children: message2 }),
-  details ? /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text15, { dimColor: true, children: details }) }) : null,
-  hint ? /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text15, { dimColor: true, children: [
+import { Box as Box16, Text as Text16 } from "ink";
+import { jsx as jsx16, jsxs as jsxs16 } from "react/jsx-runtime";
+var ErrorMessage = ({ message: message2, details, hint }) => /* @__PURE__ */ jsx16(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", paddingLeft: 2, children: [
+  /* @__PURE__ */ jsx16(Text16, { color: BLUMA_TERMINAL.err, children: message2 }),
+  details ? /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: details }) }) : null,
+  hint ? /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
     "hint: ",
     hint
   ] }) }) : null
@@ -9398,8 +10421,8 @@ var ErrorMessage_default = ErrorMessage;
 
 // src/app/ui/components/ReasoningDisplay.tsx
 import { memo as memo9 } from "react";
-import { Box as Box17, Text as Text16 } from "ink";
-import { jsx as jsx17, jsxs as jsxs16 } from "react/jsx-runtime";
+import { Box as Box17, Text as Text17 } from "ink";
+import { jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
 var ReasoningDisplayComponent = ({
   reasoning,
   collapsed = false
@@ -9411,9 +10434,9 @@ var ReasoningDisplayComponent = ({
   const lines = reasoning.split("\n");
   const displayLines = lines.slice(0, maxLines);
   const truncated = lines.length > maxLines;
-  return /* @__PURE__ */ jsx17(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", paddingLeft: 2, children: [
-    displayLines.map((line, i) => /* @__PURE__ */ jsx17(Text16, { dimColor: true, children: line }, i)),
-    truncated ? /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
+  return /* @__PURE__ */ jsx17(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", paddingLeft: 2, children: [
+    displayLines.map((line, i) => /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: line }, i)),
+    truncated ? /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
       "\u2026 +",
       lines.length - maxLines,
       " lines"
@@ -9424,8 +10447,8 @@ var ReasoningDisplay = memo9(ReasoningDisplayComponent);
 
 // src/app/ui/components/StreamingText.tsx
 import { useState as useState5, useEffect as useEffect6, useRef as useRef4, memo as memo10 } from "react";
-import { Box as Box18, Text as Text17 } from "ink";
-import { jsx as jsx18, jsxs as jsxs17 } from "react/jsx-runtime";
+import { Box as Box18, Text as Text18 } from "ink";
+import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
 var StreamingTextComponent = ({
   eventBus,
   onReasoningComplete
@@ -9491,21 +10514,21 @@ var StreamingTextComponent = ({
     truncatedCount = lines.length - MAX_VISIBLE_LINES;
     displayLines = lines.slice(-MAX_VISIBLE_LINES);
   }
-  return /* @__PURE__ */ jsx18(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", paddingLeft: 2, children: [
-    truncatedCount > 0 ? /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+  return /* @__PURE__ */ jsx18(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", paddingLeft: 2, children: [
+    truncatedCount > 0 ? /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
       "\u2026 ",
       truncatedCount,
       " lines above hidden"
     ] }) : null,
-    displayLines.map((line, i) => /* @__PURE__ */ jsx18(Text17, { dimColor: true, children: line }, i))
+    displayLines.map((line, i) => /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: line }, i))
   ] }) });
 };
 var StreamingText = memo10(StreamingTextComponent);
 
 // src/app/ui/components/ExpandedPreviewBlock.tsx
 import { memo as memo11 } from "react";
-import { Box as Box19, Text as Text18 } from "ink";
-import { jsx as jsx19, jsxs as jsxs18 } from "react/jsx-runtime";
+import { Box as Box19, Text as Text19 } from "ink";
+import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
 function ExpandedPreviewBlockComponent({ data }) {
   const cols = typeof process.stdout?.columns === "number" ? process.stdout.columns : 80;
   const rule = TERMINAL_RULE_CHAR.repeat(Math.max(8, cols));
@@ -9513,50 +10536,35 @@ function ExpandedPreviewBlockComponent({ data }) {
   const cap = EXPAND_OVERLAY_MAX_LINES;
   const shown = lines.slice(0, cap);
   const rest = lines.length - cap;
-  return /* @__PURE__ */ jsxs18(ChatBlock, { marginBottom: 1, children: [
-    /* @__PURE__ */ jsx19(Text18, { color: "white", children: rule }),
-    /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", paddingLeft: 1, children: [
-      /* @__PURE__ */ jsx19(Text18, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: "expand (Ctrl+O)" }),
-      /* @__PURE__ */ jsx19(Text18, { dimColor: true, children: data.title }),
-      /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs19(ChatBlock, { marginBottom: 1, children: [
+    /* @__PURE__ */ jsx19(Text19, { color: "white", children: rule }),
+    /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", paddingLeft: 1, children: [
+      /* @__PURE__ */ jsx19(Text19, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: "expand (Ctrl+O)" }),
+      /* @__PURE__ */ jsx19(Text19, { dimColor: true, children: data.title }),
+      /* @__PURE__ */ jsxs19(Text19, { dimColor: true, children: [
         "+",
         data.linesHidden,
         " lines were clipped in chat \xB7 below: up to ",
         cap,
         " lines \xB7 use read_file_lines before edit_tool"
       ] }),
-      /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", marginTop: 1, children: [
-        shown.map((line, i) => /* @__PURE__ */ jsx19(Text18, { dimColor: true, children: line.slice(0, 200) }, i)),
-        rest > 0 ? /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", marginTop: 1, children: [
+        shown.map((line, i) => /* @__PURE__ */ jsx19(Text19, { dimColor: true, children: line.slice(0, 200) }, i)),
+        rest > 0 ? /* @__PURE__ */ jsxs19(Text19, { dimColor: true, children: [
           "\u2026 +",
           rest,
           " more lines in this chunk"
         ] }) : null
       ] })
     ] }),
-    /* @__PURE__ */ jsx19(Text18, { color: "white", children: rule })
+    /* @__PURE__ */ jsx19(Text19, { color: "white", children: rule })
   ] });
 }
 var ExpandedPreviewBlock = memo11(ExpandedPreviewBlockComponent);
 
 // src/app/ui/App.tsx
-import { jsx as jsx20, jsxs as jsxs19 } from "react/jsx-runtime";
+import { jsx as jsx20, jsxs as jsxs20 } from "react/jsx-runtime";
 var blumaUpdateRegistryCheckStarted = false;
-var SAFE_AUTO_APPROVE_TOOLS = [
-  // Comunicação/UI
-  "message",
-  "todo",
-  "task_boundary",
-  // Leitura de ficheiros (read-only)
-  "ls_tool",
-  "read_file_lines",
-  "count_file_lines",
-  "view_file_outline",
-  "find_by_name",
-  "grep_search",
-  // Status de comandos (read-only)
-  "command_status"
-];
 function trimRecentActivity(s, max = 72) {
   const t = String(s ?? "").replace(/\s+/g, " ").trim();
   if (!t) return "";
@@ -9579,7 +10587,7 @@ function UserMessageWithOptionalImages({
         caption: cap.length > 0 ? capDisp : null,
         captionDim: true
       }
-    ) : /* @__PURE__ */ jsx20(Text19, { dimColor: true, wrap: "wrap", children: fallbackDisp }) });
+    ) : /* @__PURE__ */ jsx20(Text20, { dimColor: true, wrap: "wrap", children: fallbackDisp }) });
   }
   const displayRaw = raw.length > 1e4 ? `${raw.substring(0, 1e4)}...` : raw;
   const paths = collectImagePathStrings(displayRaw);
@@ -9590,7 +10598,7 @@ function UserMessageWithOptionalImages({
       imageCount: paths.length,
       caption: stripped.trim().length > 0 ? stripped : null
     }
-  ) : /* @__PURE__ */ jsx20(Text19, { wrap: "wrap", children: displayRaw }) });
+  ) : /* @__PURE__ */ jsx20(Text20, { wrap: "wrap", children: displayRaw }) });
 }
 var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
   const agentInstance = useRef5(null);
@@ -9611,6 +10619,10 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
   );
   const [isInitAgentActive, setIsInitAgentActive] = useState6(false);
   const [recentActivityLine, setRecentActivityLine] = useState6(null);
+  const [taskSummary, setTaskSummary] = useState6({
+    activeTaskSummary: null,
+    taskProgressSummary: null
+  });
   const alwaysAcceptList = useRef5([]);
   const workdir = process.cwd();
   const turnStartedAtRef = useRef5(null);
@@ -9648,11 +10660,11 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
     void checkForUpdates().then((msg) => {
       if (!msg) return;
       setHistory((prev) => {
-        const nextId3 = prev.length === 0 ? 1 : Math.max(...prev.map((h) => h.id), HEADER_PANEL_HISTORY_ID) + 1;
+        const nextId2 = prev.length === 0 ? 1 : Math.max(...prev.map((h) => h.id), HEADER_PANEL_HISTORY_ID) + 1;
         return [
           ...prev,
           {
-            id: nextId3,
+            id: nextId2,
             component: /* @__PURE__ */ jsx20(UpdateNotice_default, { message: msg })
           }
         ];
@@ -9671,14 +10683,16 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
               sessionId,
               workdir,
               cliVersion,
-              recentActivitySummary: recentActivityLine
+              recentActivitySummary: recentActivityLine,
+              activeTaskSummary: taskSummary.activeTaskSummary,
+              taskProgressSummary: taskSummary.taskProgressSummary
             }
           )
         },
         ...tail
       ];
     });
-  }, [sessionId, workdir, cliVersion, recentActivityLine]);
+  }, [sessionId, workdir, cliVersion, recentActivityLine, taskSummary]);
   const handleInterrupt = useCallback3(() => {
     if (!isProcessing) return;
     eventBus.emit("user_interrupt");
@@ -9739,7 +10753,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
           ...prev,
           {
             id: prev.length,
-            component: /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsx20(Text19, { dimColor: true, children: text }) })
+            component: /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: text }) })
           },
           {
             id: prev.length + 1,
@@ -9768,7 +10782,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
           ...prev,
           {
             id: prev.length,
-            component: /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsxs19(Text19, { bold: true, color: "white", children: [
+            component: /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsxs20(Text20, { bold: true, color: "white", children: [
               "$ !",
               command
             ] }) })
@@ -9791,7 +10805,7 @@ Please use command_status to check the result and report back to the user.`;
                 ...prev,
                 {
                   id: prev.length,
-                  component: /* @__PURE__ */ jsxs19(Text19, { color: "red", children: [
+                  component: /* @__PURE__ */ jsxs20(Text20, { color: "red", children: [
                     "Failed to execute: ",
                     result.error || result.message
                   ] })
@@ -9805,7 +10819,7 @@ Please use command_status to check the result and report back to the user.`;
               ...prev,
               {
                 id: prev.length,
-                component: /* @__PURE__ */ jsxs19(Text19, { color: "red", children: [
+                component: /* @__PURE__ */ jsxs20(Text20, { color: "red", children: [
                   "Error: ",
                   err.message
                 ] })
@@ -9871,6 +10885,16 @@ Please use command_status to check the result and report back to the user.`;
     };
     const handleBackendMessage = (parsed) => {
       try {
+        const updateTaskSummaryFromResult = () => {
+          const activeTask = parsed?.activeTask;
+          const stats = parsed?.stats;
+          if (activeTask || stats) {
+            setTaskSummary({
+              activeTaskSummary: activeTask ? `${String(activeTask.mode || "EXECUTION")} \xB7 ${String(activeTask.taskName || "")}${activeTask.status ? ` \xB7 ${String(activeTask.status)}` : ""}` : null,
+              taskProgressSummary: stats && typeof stats.total === "number" ? `${stats.completed ?? 0}/${stats.total ?? 0} done \xB7 ${stats.pending ?? 0} pending \xB7 ${stats.inProgress ?? 0} in progress \xB7 ${stats.progress ?? 0}%` : null
+            });
+          }
+        };
         const appendTurnDurationIfAny = () => {
           const t = turnStartedAtRef.current;
           if (t == null) return;
@@ -9893,7 +10917,8 @@ Please use command_status to check the result and report back to the user.`;
         }
         if (parsed.type === "confirmation_request") {
           const toolToConfirm = parsed.tool_calls[0].function.name;
-          if (SAFE_AUTO_APPROVE_TOOLS.includes(toolToConfirm)) {
+          const policyAutoApprove = parsed.tool_policy?.autoApprove === true;
+          if (policyAutoApprove) {
             handleConfirmation("accept", parsed.tool_calls);
             return;
           }
@@ -9929,9 +10954,9 @@ Please use command_status to check the result and report back to the user.`;
         if (parsed.type === "debug") {
           newComponent = /* @__PURE__ */ jsx20(ChatMeta, { children: parsed.message });
         } else if (parsed.type === "protocol_violation") {
-          newComponent = /* @__PURE__ */ jsx20(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", paddingLeft: 2, children: [
-            /* @__PURE__ */ jsx20(Text19, { dimColor: true, children: parsed.content }),
-            /* @__PURE__ */ jsx20(Text19, { dimColor: true, children: parsed.message })
+          newComponent = /* @__PURE__ */ jsx20(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", paddingLeft: 2, children: [
+            /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: parsed.content }),
+            /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: parsed.message })
           ] }) });
         } else if (parsed.type === "error") {
           newComponent = /* @__PURE__ */ jsx20(
@@ -9951,10 +10976,12 @@ Please use command_status to check the result and report back to the user.`;
             {
               toolName: parsed.tool_name,
               args: parsed.arguments,
-              preview: parsed.preview
+              preview: parsed.preview,
+              toolPolicy: parsed.tool_policy
             }
           );
         } else if (parsed.type === "tool_result") {
+          updateTaskSummaryFromResult();
           newComponent = /* @__PURE__ */ jsx20(
             ToolResultDisplay,
             {
@@ -9968,11 +10995,11 @@ Please use command_status to check the result and report back to the user.`;
               `Context: ${trimRecentActivity(String(parsed.payload))}`
             );
           }
-          newComponent = /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsx20(Text19, { dimColor: true, children: parsed.payload }) });
+          newComponent = /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsx20(Text20, { dimColor: true, children: parsed.payload }) });
         } else if (parsed.type === "reasoning") {
           newComponent = /* @__PURE__ */ jsx20(ReasoningDisplay, { reasoning: parsed.content });
         } else if (parsed.type === "log") {
-          newComponent = /* @__PURE__ */ jsxs19(ChatMeta, { children: [
+          newComponent = /* @__PURE__ */ jsxs20(ChatMeta, { children: [
             parsed.message,
             parsed.payload ? `: ${parsed.payload}` : ""
           ] });
@@ -10036,7 +11063,7 @@ Please use command_status to check the result and report back to the user.`;
         }
       );
     }
-    return /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", children: [
+    return /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", children: [
       isProcessing && !pendingConfirmation && /* @__PURE__ */ jsx20(WorkingTimer, { eventBus }),
       /* @__PURE__ */ jsx20(
         InputPrompt,
@@ -10049,7 +11076,7 @@ Please use command_status to check the result and report back to the user.`;
       )
     ] });
   };
-  return /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx20(Static, { items: history, children: (item) => /* @__PURE__ */ jsx20(Box20, { children: item.component }, item.id) }),
     /* @__PURE__ */ jsx20(
       StreamingText,
@@ -10148,20 +11175,90 @@ function writeJsonl(event) {
   } catch {
   }
 }
+function writeAgentEvent(sessionId, event) {
+  writeJsonl(event);
+  if (sessionId) {
+    appendSessionLog(sessionId, event);
+  }
+}
+function finalizeSession(sessionId, status, metadata) {
+  updateSession(sessionId, {
+    status,
+    pid: process.pid,
+    metadata: metadata ? { ...getSession(sessionId)?.metadata, ...metadata } : getSession(sessionId)?.metadata
+  });
+}
+function installSessionLifecycle(sessionId) {
+  let finalized = false;
+  const safeFinalize = (status, metadata) => {
+    if (finalized) return;
+    finalized = true;
+    finalizeSession(sessionId, status, metadata);
+  };
+  process.once("exit", (code) => {
+    safeFinalize(code === 0 ? "completed" : "error", { exitCode: code ?? 0 });
+  });
+  process.once("SIGINT", () => {
+    safeFinalize("cancelled", { signal: "SIGINT" });
+    process.exit(130);
+  });
+  process.once("SIGTERM", () => {
+    safeFinalize("cancelled", { signal: "SIGTERM" });
+    process.exit(143);
+  });
+  process.once("uncaughtException", (error) => {
+    safeFinalize("error", { uncaughtException: error instanceof Error ? error.message : String(error) });
+    throw error;
+  });
+}
+function formatSessionLine(session) {
+  return `${session.sessionId}  ${session.kind}  ${session.status}  ${session.updatedAt}  ${session.title}`;
+}
+function formatLogLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    const ts = parsed.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    if (parsed.event_type === "log") {
+      return `[${ts}] ${parsed.level.toUpperCase()} ${parsed.message}`;
+    }
+    if (parsed.event_type === "backend_message") {
+      return `[${ts}] EVENT ${parsed.backend_type}`;
+    }
+    if (parsed.event_type === "action_status") {
+      return `[${ts}] STATUS ${JSON.stringify(parsed.payload)}`;
+    }
+    if (parsed.event_type === "result") {
+      return `[${ts}] RESULT ${parsed.status}`;
+    }
+  } catch {
+  }
+  return line;
+}
+function isProcessAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function runAgentMode() {
   const args = process.argv.slice(2);
   const inputFileIndex = args.indexOf("--input-file");
-  const inputIndex = args.indexOf("--input");
+  const backgroundWorker = args.includes("--background-worker");
+  const registrySessionIndex = args.indexOf("--registry-session");
+  const registrySessionId = registrySessionIndex !== -1 && args[registrySessionIndex + 1] ? args[registrySessionIndex + 1] : null;
   let rawPayload = "";
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs18.readFileSync(filePath, "utf-8");
+      rawPayload = fs21.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs18.readFileSync(0, "utf-8");
+      rawPayload = fs21.readFileSync(0, "utf-8");
     }
   } catch (err) {
-    writeJsonl({
+    writeAgentEvent(registrySessionId, {
       event_type: "result",
       status: "error",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10177,7 +11274,7 @@ async function runAgentMode() {
   try {
     envelope = JSON.parse(rawPayload);
   } catch (err) {
-    writeJsonl({
+    writeAgentEvent(registrySessionId, {
       event_type: "result",
       status: "error",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10196,7 +11293,9 @@ async function runAgentMode() {
     }
   }
   const eventBus = new EventEmitter3();
-  const sessionId = envelope.session_id || envelope.message_id || uuidv46();
+  const sessionId = registrySessionId || envelope.session_id || envelope.message_id || uuidv47();
+  process.env.BLUMA_SESSION_ID = sessionId;
+  installSessionLifecycle(sessionId);
   const uc = envelope.user_context;
   const userContextInput = {
     sessionId,
@@ -10208,13 +11307,27 @@ async function runAgentMode() {
     companyId: uc?.companyId ?? null,
     companyName: uc?.companyName ?? null
   };
+  registerSession({
+    sessionId,
+    kind: "agent",
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workdir: process.cwd(),
+    title: backgroundWorker ? `background:${envelope.action || "unknown"}` : `agent:${envelope.action || "unknown"}`,
+    pid: process.pid,
+    metadata: {
+      message_id: envelope.message_id || null,
+      action: envelope.action || null,
+      background: backgroundWorker
+    }
+  });
   let lastAssistantMessage = null;
   let reasoningBuffer = null;
   let lastAttachments = null;
   let resultEmitted = false;
   eventBus.on("backend_message", (payload) => {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    writeJsonl({
+    writeAgentEvent(sessionId, {
       event_type: "backend_message",
       backend_type: String(payload?.type || "unknown"),
       timestamp,
@@ -10245,7 +11358,8 @@ async function runAgentMode() {
     }
     if (!resultEmitted && payload?.type === "done") {
       resultEmitted = true;
-      writeJsonl({
+      finalizeSession(sessionId, "completed", { finishedBy: "done-event" });
+      writeAgentEvent(sessionId, {
         event_type: "result",
         status: "success",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10261,7 +11375,7 @@ async function runAgentMode() {
     }
   });
   eventBus.on("action_status", (payload) => {
-    writeJsonl({
+    writeAgentEvent(sessionId, {
       event_type: "action_status",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       payload
@@ -10270,7 +11384,7 @@ async function runAgentMode() {
   eventBus.on("stream_reasoning_chunk", (payload) => {
     reasoningBuffer = (reasoningBuffer || "") + (payload?.delta || "");
   });
-  writeJsonl({
+  writeAgentEvent(sessionId, {
     event_type: "log",
     level: "info",
     message: "Starting agent mode execution",
@@ -10295,7 +11409,8 @@ async function runAgentMode() {
     await agent.processTurn({ content: userContent }, userContextInput);
     if (!resultEmitted) {
       resultEmitted = true;
-      writeJsonl({
+      finalizeSession(sessionId, "completed", { finishedBy: "post-turn-fallback" });
+      writeAgentEvent(sessionId, {
         event_type: "result",
         status: "success",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10311,7 +11426,8 @@ async function runAgentMode() {
     }
   } catch (err) {
     if (!resultEmitted) {
-      writeJsonl({
+      finalizeSession(sessionId, "error", { finishedBy: "exception" });
+      writeAgentEvent(sessionId, {
         event_type: "result",
         status: "error",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10326,29 +11442,177 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path22.dirname(fileURLToPath5(import.meta.url));
-    const pkgPath = path22.join(base, "..", "package.json");
-    const j = JSON.parse(fs18.readFileSync(pkgPath, "utf8"));
+    const base = path26.dirname(fileURLToPath5(import.meta.url));
+    const pkgPath = path26.join(base, "..", "package.json");
+    const j = JSON.parse(fs21.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
   }
 }
-function runCliMode() {
+function runCliMode(sessionId) {
   const BLUMA_TITLE = process.env.BLUMA_TITLE || "BluMa - NomadEngenuity";
   startTitleKeeper(BLUMA_TITLE);
   const eventBus = new EventEmitter3();
-  const sessionId = uuidv46();
+  const resolvedSessionId = sessionId || uuidv47();
+  process.env.BLUMA_SESSION_ID = resolvedSessionId;
+  registerSession({
+    sessionId: resolvedSessionId,
+    kind: "interactive",
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workdir: process.cwd(),
+    title: "interactive-cli",
+    pid: process.pid,
+    metadata: {}
+  });
+  installSessionLifecycle(resolvedSessionId);
   const props = {
     eventBus,
-    sessionId,
+    sessionId: resolvedSessionId,
     cliVersion: readCliPackageVersion()
   };
-  render(React12.createElement(App_default, props));
+  const instance = render(React12.createElement(App_default, props));
+  void instance.waitUntilExit().then(() => {
+    finalizeSession(resolvedSessionId, "completed", { finishedBy: "interactive-exit" });
+  });
+}
+function printSessions() {
+  const sessions = listSessions();
+  if (sessions.length === 0) {
+    console.log("No sessions registered.");
+    return;
+  }
+  for (const session of sessions) {
+    console.log(formatSessionLine(session));
+  }
+}
+function printSessionStatus(sessionId) {
+  const session = getSession(sessionId);
+  if (!session) {
+    console.error(`Unknown session: ${sessionId}`);
+    process.exit(1);
+    return;
+  }
+  const alive = session.status === "running" ? isProcessAlive(session.pid) : false;
+  console.log(JSON.stringify({
+    ...session,
+    alive
+  }, null, 2));
+}
+function printLogs(sessionId) {
+  const session = getSession(sessionId);
+  if (!session) {
+    console.error(`Unknown session: ${sessionId}`);
+    process.exit(1);
+  }
+  const lines = readSessionLog(sessionId);
+  for (const line of lines) {
+    console.log(formatLogLine(line));
+  }
+}
+async function attachToSession(sessionId) {
+  const session = getSession(sessionId);
+  if (!session) {
+    console.error(`Unknown session: ${sessionId}`);
+    process.exit(1);
+    return;
+  }
+  let cursor = 0;
+  while (true) {
+    const lines = readSessionLog(sessionId);
+    const next = lines.slice(cursor);
+    cursor = lines.length;
+    for (const line of next) {
+      console.log(formatLogLine(line));
+    }
+    const latest2 = getSession(sessionId);
+    if (!latest2 || latest2.status !== "running") {
+      return;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+  }
+}
+function killSession(sessionId) {
+  const session = getSession(sessionId);
+  if (!session) {
+    console.error(`Unknown session: ${sessionId}`);
+    process.exit(1);
+    return;
+  }
+  if (session.status !== "running") {
+    console.log(`Session ${sessionId} is already ${session.status}.`);
+    return;
+  }
+  if (!session.pid || !isProcessAlive(session.pid)) {
+    updateSession(sessionId, {
+      status: "cancelled",
+      metadata: { ...session.metadata, signal: "stale-process" }
+    });
+    console.log(`Session ${sessionId} was marked as cancelled because its process is not running.`);
+    return;
+  }
+  process.kill(session.pid, "SIGTERM");
+  updateSession(sessionId, {
+    status: "cancelled",
+    metadata: { ...session.metadata, signal: "SIGTERM" }
+  });
+  console.log(`Sent SIGTERM to session ${sessionId} (${session.pid}).`);
+}
+function startBackgroundAgent() {
+  const args = process.argv.slice(2);
+  const inputFileIndex = args.indexOf("--input-file");
+  if (inputFileIndex === -1 || !args[inputFileIndex + 1]) {
+    console.error("Background agent mode requires --input-file <path>.");
+    process.exit(1);
+  }
+  const filePath = args[inputFileIndex + 1];
+  const rawPayload = fs21.readFileSync(filePath, "utf-8");
+  const envelope = JSON.parse(rawPayload);
+  const sessionId = envelope.session_id || envelope.message_id || uuidv47();
+  registerSession({
+    sessionId,
+    kind: "agent",
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workdir: process.cwd(),
+    title: `background:${envelope.action || "unknown"}`,
+    metadata: {
+      action: envelope.action || null,
+      message_id: envelope.message_id || null,
+      background: true
+    }
+  });
+  const childArgs = [process.argv[1], "agent", "--input-file", filePath, "--background-worker", "--registry-session", sessionId];
+  const child = spawn4(process.execPath, childArgs, {
+    detached: true,
+    stdio: "ignore",
+    cwd: process.cwd(),
+    env: process.env
+  });
+  child.unref();
+  updateSession(sessionId, { pid: child.pid });
+  console.log(sessionId);
 }
 var argv = process.argv.slice(2);
-if (argv[0] === "agent") {
+if (argv[0] === "agent" && argv.includes("--background")) {
+  startBackgroundAgent();
+} else if (argv[0] === "agent") {
   runAgentMode();
+} else if (argv[0] === "sessions") {
+  printSessions();
+} else if (argv[0] === "logs" && argv[1]) {
+  printLogs(argv[1]);
+} else if (argv[0] === "status" && argv[1]) {
+  printSessionStatus(argv[1]);
+} else if (argv[0] === "attach" && argv[1]) {
+  attachToSession(argv[1]);
+} else if (argv[0] === "follow" && argv[1]) {
+  attachToSession(argv[1]);
+} else if (argv[0] === "kill" && argv[1]) {
+  killSession(argv[1]);
+} else if (argv[0] === "resume" && argv[1]) {
+  runCliMode(argv[1]);
 } else {
   runCliMode();
 }