@nomad-e/bluma-cli 0.1.51 → 0.1.53

package/dist/main.js

@@ -496,19 +496,701 @@ var init_async_command = __esm({
   }
 });
 
+// src/app/agent/runtime/session_registry.ts
+var session_registry_exports = {};
+__export(session_registry_exports, {
+  appendSessionLog: () => appendSessionLog,
+  getSession: () => getSession,
+  getSessionLogPath: () => getSessionLogPath,
+  listSessions: () => listSessions,
+  readSessionLog: () => readSessionLog,
+  registerSession: () => registerSession,
+  updateSession: () => updateSession
+});
+import fs15 from "fs";
+import os8 from "os";
+import path17 from "path";
+function getRegistryDir() {
+  return path17.join(process.env.HOME || os8.homedir(), ".bluma", "registry");
+}
+function getRegistryFile() {
+  return path17.join(getRegistryDir(), "sessions.json");
+}
+function ensureRegistryDir() {
+  fs15.mkdirSync(getRegistryDir(), { recursive: true });
+}
+function readRegistry() {
+  ensureRegistryDir();
+  const file = getRegistryFile();
+  if (!fs15.existsSync(file)) {
+    return { entries: [] };
+  }
+  try {
+    return JSON.parse(fs15.readFileSync(file, "utf-8"));
+  } catch {
+    return { entries: [] };
+  }
+}
+function writeRegistry(state) {
+  ensureRegistryDir();
+  fs15.writeFileSync(getRegistryFile(), JSON.stringify(state, null, 2), "utf-8");
+}
+function getSessionLogPath(sessionId) {
+  ensureRegistryDir();
+  return path17.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);
+  fs15.appendFileSync(logFile, `${JSON.stringify(payload)}
+`, "utf-8");
+}
+function readSessionLog(sessionId) {
+  const logFile = getSessionLogPath(sessionId);
+  if (!fs15.existsSync(logFile)) return [];
+  return fs15.readFileSync(logFile, "utf-8").split("\n").filter(Boolean);
+}
+var init_session_registry = __esm({
+  "src/app/agent/runtime/session_registry.ts"() {
+    "use strict";
+  }
+});
+
+// src/app/agent/tools/natives/agent_coordination.ts
+var agent_coordination_exports = {};
+__export(agent_coordination_exports, {
+  listAgents: () => listAgents,
+  spawnAgent: () => spawnAgent,
+  waitAgent: () => waitAgent
+});
+import fs16 from "fs";
+import os9 from "os";
+import path18 from "path";
+import { spawn as spawn4 } from "child_process";
+import { v4 as uuidv43 } from "uuid";
+function readUserContextFromEnv() {
+  const raw = process.env.BLUMA_USER_CONTEXT_JSON;
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      conversationId: parsed.conversationId ?? null,
+      userId: parsed.userId ?? null,
+      userName: parsed.userName ?? null,
+      userEmail: parsed.userEmail ?? null,
+      companyId: parsed.companyId ?? null,
+      companyName: parsed.companyName ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function buildWorkerPayload(sessionId, args, parentSessionId, userContext) {
+  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"
+    },
+    user_context: userContext || void 0,
+    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 userContext = readUserContextFromEnv();
+  const title = args.title || `worker:${args.agent_type || "worker"}`;
+  const payload = buildWorkerPayload(sessionId, args, parentSessionId, userContext);
+  const payloadDir = fs16.mkdtempSync(path18.join(os9.tmpdir(), "bluma-worker-"));
+  const payloadPath = path18.join(payloadDir, `${sessionId}.json`);
+  fs16.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",
+      user_id: userContext?.userId ?? null,
+      company_id: userContext?.companyId ?? null
+    }
+  });
+  const child = spawn4(
+    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
+  };
+}
+var init_agent_coordination = __esm({
+  "src/app/agent/tools/natives/agent_coordination.ts"() {
+    "use strict";
+    init_session_registry();
+  }
+});
+
+// src/app/agent/runtime/mailbox_registry.ts
+var mailbox_registry_exports = {};
+__export(mailbox_registry_exports, {
+  ensureMailbox: () => ensureMailbox,
+  listActiveMailboxes: () => listActiveMailboxes,
+  pruneMailbox: () => pruneMailbox,
+  readFromMailbox: () => readFromMailbox,
+  readSignals: () => readSignals,
+  removeMailbox: () => removeMailbox,
+  sendFollowUp: () => sendFollowUp,
+  sendPermissionRequest: () => sendPermissionRequest,
+  sendPermissionResponse: () => sendPermissionResponse,
+  sendProgressUpdate: () => sendProgressUpdate,
+  sendSignal: () => sendSignal,
+  sendToMailbox: () => sendToMailbox
+});
+import fs17 from "fs";
+import os10 from "os";
+import path19 from "path";
+import { v4 as uuidv44 } from "uuid";
+function getMailboxesDir() {
+  if (mailboxesDir) {
+    return mailboxesDir;
+  }
+  mailboxesDir = path19.join(process.env.HOME || os10.homedir(), ".bluma", "mailboxes");
+  fs17.mkdirSync(mailboxesDir, { recursive: true });
+  return mailboxesDir;
+}
+function getMailboxPath(sessionId, type) {
+  const dir = getMailboxesDir();
+  return path19.join(dir, `${sessionId}.${type}`);
+}
+function ensureMailbox(sessionId) {
+  const dir = getMailboxesDir();
+  const types = ["in", "out", "sig"];
+  for (const type of types) {
+    const filePath = path19.join(dir, `${sessionId}.${type}`);
+    if (!fs17.existsSync(filePath)) {
+      fs17.writeFileSync(filePath, "", "utf-8");
+    }
+  }
+}
+function sendToMailbox(sessionId, type, message2) {
+  const filePath = getMailboxPath(sessionId, type);
+  const fullMessage = {
+    ...message2,
+    id: uuidv44(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const line = JSON.stringify(fullMessage) + "\n";
+  fs17.appendFileSync(filePath, line, "utf-8");
+  return fullMessage.id;
+}
+function readFromMailbox(sessionId, type, lastReadId) {
+  const filePath = getMailboxPath(sessionId, type);
+  if (!fs17.existsSync(filePath)) {
+    return [];
+  }
+  const content = fs17.readFileSync(filePath, "utf-8");
+  if (!content.trim()) {
+    return [];
+  }
+  const lines = content.trim().split("\n");
+  const messages = [];
+  let shouldStartReading = !lastReadId;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+      if (lastReadId && !shouldStartReading) {
+        if (msg.id === lastReadId) {
+          shouldStartReading = true;
+        }
+        continue;
+      }
+      messages.push(msg);
+    } catch {
+    }
+  }
+  return messages;
+}
+function pruneMailbox(sessionId, type, keepLast = 100) {
+  const filePath = getMailboxPath(sessionId, type);
+  if (!fs17.existsSync(filePath)) {
+    return;
+  }
+  const content = fs17.readFileSync(filePath, "utf-8");
+  if (!content.trim()) {
+    return;
+  }
+  const lines = content.trim().split("\n").filter((l) => l.trim());
+  if (lines.length <= keepLast) {
+    return;
+  }
+  const pruned = lines.slice(-keepLast);
+  fs17.writeFileSync(filePath, pruned.join("\n") + "\n", "utf-8");
+}
+function sendSignal(sessionId, type, data, messageId) {
+  const filePath = getMailboxPath(sessionId, "sig");
+  const signal = {
+    id: uuidv44(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    type,
+    messageId,
+    data
+  };
+  const line = JSON.stringify(signal) + "\n";
+  fs17.appendFileSync(filePath, line, "utf-8");
+  return signal.id;
+}
+function readSignals(sessionId, lastReadId) {
+  const filePath = getMailboxPath(sessionId, "sig");
+  if (!fs17.existsSync(filePath)) {
+    return [];
+  }
+  const content = fs17.readFileSync(filePath, "utf-8");
+  if (!content.trim()) {
+    return [];
+  }
+  const lines = content.trim().split("\n");
+  const signals = [];
+  let shouldStartReading = !lastReadId;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const signal = JSON.parse(line);
+      if (lastReadId && !shouldStartReading) {
+        if (signal.id === lastReadId) {
+          shouldStartReading = true;
+        }
+        continue;
+      }
+      signals.push(signal);
+    } catch {
+    }
+  }
+  return signals;
+}
+function removeMailbox(sessionId) {
+  const dir = getMailboxesDir();
+  const types = ["in", "out", "sig"];
+  for (const type of types) {
+    const filePath = path19.join(dir, `${sessionId}.${type}`);
+    if (fs17.existsSync(filePath)) {
+      fs17.unlinkSync(filePath);
+    }
+  }
+}
+function listActiveMailboxes() {
+  const dir = getMailboxesDir();
+  if (!fs17.existsSync(dir)) {
+    return [];
+  }
+  const files = fs17.readdirSync(dir);
+  const mailboxes = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const match = file.match(/^([a-f0-9-]+)\.(in|out|sig)$/);
+    if (!match) continue;
+    const sessionId = match[1];
+    const type = match[2];
+    if (!mailboxes.has(sessionId)) {
+      mailboxes.set(sessionId, { in: 0, out: 0, sig: 0 });
+    }
+    const filePath = path19.join(dir, file);
+    const content = fs17.readFileSync(filePath, "utf-8");
+    const lines = content.trim().split("\n").filter((l) => l.trim()).length;
+    mailboxes.get(sessionId)[type] = lines;
+  }
+  return Array.from(mailboxes.entries()).map(([sessionId, counts]) => ({
+    sessionId,
+    hasMessages: counts.in > 0 || counts.out > 0 || counts.sig > 0
+  }));
+}
+function sendFollowUp(workerSessionId, coordinatorSessionId, message2, requiresAck = true) {
+  return sendToMailbox(workerSessionId, "in", {
+    type: "follow_up",
+    from: coordinatorSessionId,
+    to: workerSessionId,
+    content: message2,
+    metadata: {
+      priority: "normal",
+      requiresAck
+    }
+  });
+}
+function sendProgressUpdate(coordinatorSessionId, workerSessionId, percent, currentTask, toolCallsCount, tokensUsed) {
+  return sendToMailbox(coordinatorSessionId, "out", {
+    type: "progress_update",
+    from: workerSessionId,
+    to: coordinatorSessionId,
+    content: currentTask || `Progress: ${percent}%`,
+    metadata: {
+      priority: "low",
+      requiresAck: false,
+      progress: {
+        percent,
+        currentTask,
+        toolCallsCount,
+        tokensUsed
+      }
+    }
+  });
+}
+function sendPermissionRequest(coordinatorSessionId, workerSessionId, toolName, toolArgs, reason) {
+  return sendToMailbox(coordinatorSessionId, "out", {
+    type: "permission_request",
+    from: workerSessionId,
+    to: coordinatorSessionId,
+    content: `Permission request: ${toolName}`,
+    metadata: {
+      priority: "high",
+      requiresAck: true,
+      permission: {
+        toolName,
+        toolArgs,
+        reason
+      }
+    }
+  });
+}
+function sendPermissionResponse(workerSessionId, coordinatorSessionId, approved, reason) {
+  return sendToMailbox(workerSessionId, "in", {
+    type: "permission_response",
+    from: coordinatorSessionId,
+    to: workerSessionId,
+    content: approved ? "approved" : "denied",
+    metadata: {
+      priority: "urgent",
+      requiresAck: true,
+      permission: {
+        toolName: "permission_response",
+        toolArgs: { approved, reason },
+        reason: reason || ""
+      }
+    }
+  });
+}
+var mailboxesDir;
+var init_mailbox_registry = __esm({
+  "src/app/agent/runtime/mailbox_registry.ts"() {
+    "use strict";
+    mailboxesDir = null;
+  }
+});
+
+// src/app/agent/tools/natives/list_mailbox_messages.ts
+var list_mailbox_messages_exports = {};
+__export(list_mailbox_messages_exports, {
+  listMailboxMessages: () => listMailboxMessages
+});
+async function listMailboxMessages(args = {}) {
+  const {
+    from,
+    type,
+    unreadOnly = true,
+    lastReadId,
+    includeSignals = false,
+    prune = false
+  } = args;
+  const coordinatorSessionId = process.env.BLUMA_SESSION_ID || "unknown";
+  const allMessages = [];
+  if (from) {
+    const messages = readFromMailbox(from, "out", lastReadId);
+    for (const msg of messages) {
+      if (!type || msg.type === type) {
+        allMessages.push({ ...msg, direction: "out" });
+      }
+    }
+  } else {
+    const { listActiveMailboxes: listActiveMailboxes2 } = await Promise.resolve().then(() => (init_mailbox_registry(), mailbox_registry_exports));
+    const { getSession: getSession2 } = await Promise.resolve().then(() => (init_session_registry(), session_registry_exports));
+    const activeMailboxes = listActiveMailboxes2();
+    const workers = [];
+    for (const { sessionId } of activeMailboxes) {
+      const session = getSession2(sessionId);
+      if (!session || session.kind !== "agent") continue;
+      const messages = readFromMailbox(sessionId, "out", lastReadId);
+      let messageCount = 0;
+      for (const msg of messages) {
+        if (!type || msg.type === type) {
+          allMessages.push({ ...msg, direction: "out" });
+          messageCount++;
+        }
+      }
+      workers.push({
+        sessionId,
+        status: session.status,
+        messageCount
+      });
+    }
+    if (workers.length > 0) {
+      return {
+        success: true,
+        messages: allMessages.sort(
+          (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+        ),
+        count: allMessages.length,
+        lastMessageId: allMessages[allMessages.length - 1]?.id,
+        workers
+      };
+    }
+  }
+  allMessages.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  let signals;
+  if (includeSignals && from) {
+    signals = readSignals(from, lastReadId);
+  }
+  if (prune && from) {
+    pruneMailbox(from, "out", 50);
+  }
+  return {
+    success: true,
+    messages: allMessages,
+    signals,
+    count: allMessages.length,
+    lastMessageId: allMessages[allMessages.length - 1]?.id
+  };
+}
+var init_list_mailbox_messages = __esm({
+  "src/app/agent/tools/natives/list_mailbox_messages.ts"() {
+    "use strict";
+    init_mailbox_registry();
+  }
+});
+
+// src/app/agent/tools/natives/poll_mailbox.ts
+var poll_mailbox_exports = {};
+__export(poll_mailbox_exports, {
+  pollMailbox: () => pollMailbox
+});
+async function pollMailbox(args = {}) {
+  const {
+    timeout = 0,
+    pollInterval = 500,
+    types,
+    lastReadId,
+    includeSignals = true
+  } = args;
+  const sessionId = process.env.BLUMA_SESSION_ID;
+  if (!sessionId) {
+    return {
+      success: false,
+      messages: [],
+      count: 0,
+      hasNewMessages: false,
+      error: "BLUMA_SESSION_ID not set"
+    };
+  }
+  ensureMailbox(sessionId);
+  const deadline = Date.now() + timeout;
+  let messages = [];
+  let signals = [];
+  do {
+    messages = readFromMailbox(sessionId, "in", lastReadId);
+    if (types && types.length > 0) {
+      messages = messages.filter((msg) => types.includes(msg.type));
+    }
+    if (messages.length > 0) {
+      break;
+    }
+    if (timeout > 0 && Date.now() < deadline) {
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+    }
+  } while (timeout > 0 && Date.now() < deadline);
+  if (includeSignals) {
+    signals = readSignals(sessionId, lastReadId);
+  }
+  const followUpMessage = messages.find((msg) => msg.type === "follow_up");
+  const followUp = followUpMessage ? {
+    message: followUpMessage.content,
+    priority: followUpMessage.metadata?.priority || "normal",
+    messageId: followUpMessage.id
+  } : void 0;
+  const cancelRequested = messages.some((msg) => msg.type === "cancel_request") || signals.some((sig) => sig.type === "progress" && sig.data?.event === "cancel");
+  const permissionResponseMsg = messages.find((msg) => msg.type === "permission_response");
+  const permissionResponse = permissionResponseMsg ? {
+    approved: permissionResponseMsg.content === "approved",
+    reason: permissionResponseMsg.metadata?.permission?.reason,
+    messageId: permissionResponseMsg.id
+  } : void 0;
+  return {
+    success: true,
+    messages,
+    signals,
+    count: messages.length,
+    hasNewMessages: messages.length > 0,
+    lastMessageId: messages[messages.length - 1]?.id,
+    followUp,
+    cancelRequested,
+    permissionResponse
+  };
+}
+var init_poll_mailbox = __esm({
+  "src/app/agent/tools/natives/poll_mailbox.ts"() {
+    "use strict";
+    init_mailbox_registry();
+  }
+});
+
 // src/main.ts
-import React16 from "react";
+import React19 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter3 } from "events";
-import fs27 from "fs";
-import path32 from "path";
+import fs29 from "fs";
+import path34 from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { spawn as spawn5 } from "child_process";
-import { v4 as uuidv47 } from "uuid";
+import { v4 as uuidv48 } from "uuid";
 
 // src/app/ui/App.tsx
-import { useState as useState8, useEffect as useEffect8, useRef as useRef6, useCallback as useCallback3, memo as memo15 } from "react";
-import { Box as Box23, Text as Text22, Static } from "ink";
+import { useState as useState11, useEffect as useEffect11, useRef as useRef6, useCallback as useCallback4, memo as memo15 } from "react";
+import { Box as Box26, Text as Text25, Static, useInput as useInput6 } from "ink";
 
 // src/app/ui/layout.tsx
 import { Box, Text } from "ink";
@@ -2970,12 +3652,12 @@ function EditToolDiffPanel({
   maxHeight = EDIT_DIFF_PREVIEW_MAX_LINES,
   fallbackSnippet
 }) {
-  const path33 = filePath.trim() || "unknown file";
+  const path35 = filePath.trim() || "unknown file";
   const diff = diffText?.trim() ?? "";
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx5(Box5, { flexDirection: "row", flexWrap: "wrap", children: /* @__PURE__ */ jsxs5(Text5, { color: isNewFile ? BLUMA_TERMINAL.success : void 0, children: [
       isNewFile ? "Created " : "Wrote to ",
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: path33 })
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: path35 })
     ] }) }),
     description ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, wrap: "wrap", children: description }) : null,
     diff.length > 0 ? /* @__PURE__ */ jsx5(Box5, { marginTop: 0, children: /* @__PURE__ */ jsx5(SimpleDiff, { text: diff, maxHeight, frame: true }) }) : fallbackSnippet ? /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 0, children: [
@@ -3209,7 +3891,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path33 = parsed.path || ".";
+  const path35 = parsed.path || ".";
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "row", flexWrap: "wrap", children: [
     /* @__PURE__ */ jsxs7(Text7, { color: BLUMA_TERMINAL.muted, children: [
       '"',
@@ -3218,7 +3900,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs7(Text7, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, children: [
       " ",
-      path33
+      path35
     ] })
   ] });
 };
@@ -3625,7 +4307,7 @@ var ConfirmationPromptComponent = ({ toolCalls, preview, onDecision }) => {
   const rule = TERMINAL_RULE_CHAR.repeat(Math.min(cols - 2, 64));
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginBottom: 1, paddingX: 0, children: [
     /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: rule }),
-    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", marginTop: 0, marginBottom: 1, flexWrap: "wrap", alignItems: "baseline", children: [
+    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", marginTop: 0, marginBottom: 1, flexWrap: "wrap", alignItems: "flex-end", children: [
       /* @__PURE__ */ jsx8(Text8, { color: shellLike ? BLUMA_TERMINAL.m3OnSurface : BLUMA_TERMINAL.inactive, children: TOOL_INVOCATION_MARK }),
       /* @__PURE__ */ jsx8(Text8, { color: shellLike ? BLUMA_TERMINAL.m3OnSurface : BLUMA_TERMINAL.claude, bold: true, children: getToolInvocationTitle(toolName, toolCall.function.arguments) }),
       /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " \xB7 permission required" }),
@@ -3648,12 +4330,12 @@ var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path30 from "path";
-import os19 from "os";
+import path32 from "path";
+import os21 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs17 } from "fs";
-import path19 from "path";
+import { promises as fs18 } from "fs";
+import path20 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/app/agent/tools/natives/edit.ts
@@ -5345,13 +6027,11 @@ init_async_command();
 init_sandbox_policy();
 import path13 from "path";
 import { promises as fs10 } from "fs";
-import os7 from "os";
 var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
   const policy = getSandboxPolicy();
-  const homeDir = os7.homedir();
-  const baseDir = policy.isSandbox ? path13.join(policy.workspaceRoot, "artifacts") : path13.join(homeDir, ".bluma", "artifacts");
+  const baseDir = path13.join(policy.workspaceRoot, ".bluma", "artifacts");
   const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
   artifactsDir = path13.join(baseDir, sessionId);
   await fs10.mkdir(artifactsDir, { recursive: true });
@@ -5887,7 +6567,7 @@ ${skill.content}`;
 // src/app/agent/tools/natives/coding_memory.ts
 import * as fs11 from "fs";
 import * as path14 from "path";
-import os8 from "os";
+import os7 from "os";
 var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
 var PROMPT_DEFAULT_MAX_NOTES = 25;
 var PROMPT_DEFAULT_PREVIEW = 500;
@@ -5895,7 +6575,7 @@ 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 = path14.join(os8.homedir(), ".bluma", "coding_memory.json");
+  const globalPath = path14.join(os7.homedir(), ".bluma", "coding_memory.json");
   const legacyPath = path14.join(process.cwd(), ".bluma", "coding_memory.json");
   let raw = null;
   try {
@@ -5940,7 +6620,7 @@ var memoryStore = [];
 var nextId = 1;
 var loaded = false;
 function getMemoryFilePath() {
-  return path14.join(os8.homedir(), ".bluma", "coding_memory.json");
+  return path14.join(os7.homedir(), ".bluma", "coding_memory.json");
 }
 function getLegacyMemoryFilePath() {
   return path14.join(process.cwd(), ".bluma", "coding_memory.json");
@@ -6868,294 +7548,195 @@ function stripHtml(html) {
 }
 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 fs16 from "fs";
-import os10 from "os";
-import path18 from "path";
-import { spawn as spawn4 } from "child_process";
-import { v4 as uuidv43 } from "uuid";
-
-// src/app/agent/runtime/session_registry.ts
-import fs15 from "fs";
-import os9 from "os";
-import path17 from "path";
-function getRegistryDir() {
-  return path17.join(process.env.HOME || os9.homedir(), ".bluma", "registry");
-}
-function getRegistryFile() {
-  return path17.join(getRegistryDir(), "sessions.json");
-}
-function ensureRegistryDir() {
-  fs15.mkdirSync(getRegistryDir(), { recursive: true });
-}
-function readRegistry() {
-  ensureRegistryDir();
-  const file = getRegistryFile();
-  if (!fs15.existsSync(file)) {
-    return { entries: [] };
-  }
-  try {
-    return JSON.parse(fs15.readFileSync(file, "utf-8"));
-  } catch {
-    return { entries: [] };
-  }
-}
-function writeRegistry(state) {
-  ensureRegistryDir();
-  fs15.writeFileSync(getRegistryFile(), JSON.stringify(state, null, 2), "utf-8");
-}
-function getSessionLogPath(sessionId) {
-  ensureRegistryDir();
-  return path17.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);
-  fs15.appendFileSync(logFile, `${JSON.stringify(payload)}
-`, "utf-8");
-}
-function readSessionLog(sessionId) {
-  const logFile = getSessionLogPath(sessionId);
-  if (!fs15.existsSync(logFile)) return [];
-  return fs15.readFileSync(logFile, "utf-8").split("\n").filter(Boolean);
-}
-
-// src/app/agent/tools/natives/agent_coordination.ts
-function readUserContextFromEnv() {
-  const raw = process.env.BLUMA_USER_CONTEXT_JSON;
-  if (!raw) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    return {
-      conversationId: parsed.conversationId ?? null,
-      userId: parsed.userId ?? null,
-      userName: parsed.userName ?? null,
-      userEmail: parsed.userEmail ?? null,
-      companyId: parsed.companyId ?? null,
-      companyName: parsed.companyName ?? null
-    };
-  } catch {
-    return null;
-  }
-}
-function buildWorkerPayload(sessionId, args, parentSessionId, userContext) {
-  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"
-    },
-    user_context: userContext || void 0,
-    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 userContext = readUserContextFromEnv();
-  const title = args.title || `worker:${args.agent_type || "worker"}`;
-  const payload = buildWorkerPayload(sessionId, args, parentSessionId, userContext);
-  const payloadDir = fs16.mkdtempSync(path18.join(os10.tmpdir(), "bluma-worker-"));
-  const payloadPath = path18.join(payloadDir, `${sessionId}.json`);
-  fs16.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",
-      user_id: userContext?.userId ?? null,
-      company_id: userContext?.companyId ?? null
-    }
-  });
-  const child = spawn4(
-    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"
-  };
+  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)
+    };
+  }
 }
-async function waitAgent(args) {
-  const sessionId = args?.session_id;
-  if (!sessionId || typeof sessionId !== "string") {
-    return { success: false, error: "session_id is required" };
+
+// src/app/agent/runtime/native_tool_catalog.ts
+init_agent_coordination();
+
+// src/app/agent/tools/natives/send_message.ts
+init_session_registry();
+init_mailbox_registry();
+async function sendMessage(args) {
+  const { to, message: message2, priority = "normal", waitForAck = false, ackTimeout = 3e4 } = args;
+  if (!to || typeof to !== "string") {
+    return {
+      success: false,
+      message_id: "",
+      worker_session_id: to,
+      status: "error",
+      error: "to (worker 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") {
+  if (!message2 || typeof message2 !== "string") {
+    return {
+      success: false,
+      message_id: "",
+      worker_session_id: to,
+      status: "error",
+      error: "message is required"
+    };
+  }
+  const workerSession = getSession(to);
+  if (!workerSession) {
+    return {
+      success: false,
+      message_id: "",
+      worker_session_id: to,
+      status: "error",
+      error: `Worker session ${to} not found`
+    };
+  }
+  if (workerSession.status !== "running") {
+    return {
+      success: false,
+      message_id: "",
+      worker_session_id: to,
+      status: "error",
+      error: `Worker session ${to} is ${workerSession.status}, cannot send follow-up`
+    };
+  }
+  const messageId = sendFollowUp(to, process.env.BLUMA_SESSION_ID || "unknown", message2, waitForAck);
+  if (waitForAck) {
+    const ackResult = await waitForAckSignal(to, messageId, ackTimeout);
+    if (!ackResult.acknowledged) {
       return {
-        success: true,
-        completed: true,
-        session: toAgentSummary(session2),
-        result: extractLatestResult(sessionId)
+        success: false,
+        message_id: messageId,
+        worker_session_id: to,
+        status: ackResult.timedOut ? "timeout" : "error",
+        error: ackResult.error,
+        ack_received: false,
+        worker_status: workerSession.status
       };
     }
-    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}.`
+    message_id: messageId,
+    worker_session_id: to,
+    status: waitForAck ? "delivered" : "sent",
+    ack_received: waitForAck,
+    worker_status: workerSession.status
   };
 }
-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;
+async function waitForAckSignal(sessionId, messageId, timeoutMs) {
+  const { readSignals: readSignals2 } = await Promise.resolve().then(() => (init_mailbox_registry(), mailbox_registry_exports));
+  const deadline = Date.now() + timeoutMs;
+  const pollInterval = 500;
+  while (Date.now() < deadline) {
+    const signals = readSignals2(sessionId);
+    for (const signal of signals) {
+      if (signal.messageId === messageId) {
+        if (signal.type === "ack") {
+          return { acknowledged: true };
+        } else if (signal.type === "nack") {
+          return {
+            acknowledged: false,
+            error: signal.data?.reason || "Worker rejected message"
+          };
+        }
+      }
     }
-    return true;
-  }).map(toAgentSummary);
+    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+  }
+  return { acknowledged: false, timedOut: true, error: `Timeout waiting for ack after ${timeoutMs}ms` };
+}
+
+// src/app/agent/runtime/native_tool_catalog.ts
+init_list_mailbox_messages();
+init_poll_mailbox();
+
+// src/app/agent/tools/natives/signal_mailbox.ts
+init_mailbox_registry();
+async function signalMailbox(args) {
+  const { to, type, messageId, data, progress, permissionResponse } = args;
+  if (!to || typeof to !== "string") {
+    return {
+      success: false,
+      signal_id: "",
+      type,
+      to,
+      error: "to (session ID) is required"
+    };
+  }
+  if (!type || !["ack", "nack", "progress", "heartbeat"].includes(type)) {
+    return {
+      success: false,
+      signal_id: "",
+      type,
+      to,
+      error: "type must be one of: ack, nack, progress, heartbeat"
+    };
+  }
+  if (type === "progress" && progress) {
+    const sessionId = process.env.BLUMA_SESSION_ID || "unknown";
+    const signalId2 = sendProgressUpdate(
+      to,
+      sessionId,
+      progress.percent,
+      progress.currentTask,
+      progress.toolCallsCount,
+      progress.tokensUsed
+    );
+    return {
+      success: true,
+      signal_id: signalId2,
+      type: "progress",
+      to
+    };
+  }
+  if (type === "ack" && permissionResponse) {
+    const sessionId = process.env.BLUMA_SESSION_ID || "unknown";
+    const signalId2 = sendPermissionResponse(
+      to,
+      sessionId,
+      permissionResponse.approved,
+      permissionResponse.reason
+    );
+    return {
+      success: true,
+      signal_id: signalId2,
+      type: permissionResponse.approved ? "ack" : "nack",
+      to
+    };
+  }
+  const signalId = sendSignal(to, type, data, messageId);
   return {
     success: true,
-    count: entries.length,
-    agents: entries
+    signal_id: signalId,
+    type,
+    to
   };
 }
 
@@ -7589,6 +8170,50 @@ var NATIVE_TOOL_ENTRIES = [
       description: "LSP definition/references (TS/JS MVP)."
     },
     implementation: lsp_query
+  },
+  {
+    metadata: {
+      name: "send_message",
+      category: "communication",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Send a follow-up message to a running worker. Allows continuing a worker with new instructions without re-spawning (preserves loaded context)."
+    },
+    implementation: sendMessage
+  },
+  {
+    metadata: {
+      name: "list_mailbox_messages",
+      category: "communication",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "List messages received from workers (progress updates, permission requests, etc.). Coordinator uses this to read worker responses."
+    },
+    implementation: listMailboxMessages
+  },
+  {
+    metadata: {
+      name: "poll_mailbox",
+      category: "communication",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Poll mailbox for new messages from coordinator. Worker uses this to check for follow-ups, cancel requests, or permission responses."
+    },
+    implementation: pollMailbox
+  },
+  {
+    metadata: {
+      name: "signal_mailbox",
+      category: "communication",
+      riskLevel: "safe",
+      autoApproveInLocal: true,
+      autoApproveInSandbox: true,
+      description: "Send control signals (ack/nack/progress/heartbeat). Used by both coordinator and workers for flow control and status updates."
+    },
+    implementation: signalMailbox
   }
 ];
 var TOOL_METADATA_MAP = new Map(
@@ -7629,9 +8254,9 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const __filename = fileURLToPath2(import.meta.url);
-      const __dirname = path19.dirname(__filename);
-      const configPath = path19.resolve(__dirname, "config", "native_tools.json");
-      const fileContent = await fs17.readFile(configPath, "utf-8");
+      const __dirname = path20.dirname(__filename);
+      const configPath = path20.resolve(__dirname, "config", "native_tools.json");
+      const fileContent = await fs18.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = applyMetadataToToolDefinitions(config2.nativeTools);
     } catch (error) {
@@ -7673,8 +8298,8 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs18 } from "fs";
-import path20 from "path";
+import { promises as fs19 } from "fs";
+import path21 from "path";
 import os11 from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
@@ -7702,9 +8327,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath3(import.meta.url);
-    const __dirname = path20.dirname(__filename);
-    const defaultConfigPath = path20.resolve(__dirname, "config", "bluma-mcp.json");
-    const userConfigPath = path20.join(os11.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname = path21.dirname(__filename);
+    const defaultConfigPath = path21.resolve(__dirname, "config", "bluma-mcp.json");
+    const userConfigPath = path21.join(os11.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -7738,7 +8363,7 @@ var MCPClient = class {
   }
   async loadMcpConfig(configPath, configType) {
     try {
-      const fileContent = await fs18.readFile(configPath, "utf-8");
+      const fileContent = await fs19.readFile(configPath, "utf-8");
       const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
@@ -7909,13 +8534,13 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path28 from "path";
-import { v4 as uuidv44 } from "uuid";
+import path30 from "path";
+import { v4 as uuidv45 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path21 from "path";
+import path22 from "path";
 import os12 from "os";
-import { promises as fs19 } from "fs";
+import { promises as fs20 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -7951,13 +8576,13 @@ function debouncedSave(sessionFile, history, memory) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path21.join(os12.homedir(), p.slice(1));
+    return path22.join(os12.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path21.join(os12.homedir(), ".bluma");
-  return path21.resolve(expandHome(fixed));
+  const fixed = path22.join(os12.homedir(), ".bluma");
+  return path22.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -7965,10 +8590,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path21.dirname(dest);
-      await fs19.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path22.dirname(dest);
+      await fs20.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs19.rename(src, dest);
+      await fs20.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -7981,13 +8606,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs19.access(src);
-    const data = await fs19.readFile(src);
-    const dir = path21.dirname(dest);
-    await fs19.mkdir(dir, { recursive: true }).catch(() => {
+    await fs20.access(src);
+    const data = await fs20.readFile(src);
+    const dir = path22.dirname(dest);
+    await fs20.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs19.writeFile(dest, data);
-    await fs19.unlink(src).catch(() => {
+    await fs20.writeFile(dest, data);
+    await fs20.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -8000,16 +8625,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path21.join(appDir, "sessions");
-  await fs19.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path22.join(appDir, "sessions");
+  await fs20.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadOrcreateSession(sessionId) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path21.join(sessionDir, `${sessionId}.json`);
+  const sessionFile = path22.join(sessionDir, `${sessionId}.json`);
   try {
-    await fs19.access(sessionFile);
-    const fileContent = await fs19.readFile(sessionFile, "utf-8");
+    await fs20.access(sessionFile);
+    const fileContent = await fs20.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     const memory = {
       historyAnchor: sessionData.history_anchor ?? null,
@@ -8022,7 +8647,7 @@ async function loadOrcreateSession(sessionId) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
-    await fs19.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    await fs20.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     const emptyMemory = {
       historyAnchor: null,
       compressedTurnSliceCount: 0
@@ -8034,12 +8659,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path21.dirname(sessionFile);
-      await fs19.mkdir(dir, { recursive: true });
+      const dir = path22.dirname(sessionFile);
+      await fs20.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs19.readFile(sessionFile, "utf-8");
+      const fileContent = await fs20.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -8050,14 +8675,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path21.basename(sessionFile, ".json");
+      const sessionId = path22.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs19.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs20.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -8073,7 +8698,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     }
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs19.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs20.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -8082,7 +8707,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs19.unlink(tempSessionFile);
+        await fs20.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -8099,14 +8724,14 @@ async function saveSessionHistory(sessionFile, history, memory) {
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
-import os15 from "os";
-import fs23 from "fs";
-import path25 from "path";
+import os16 from "os";
+import fs25 from "fs";
+import path27 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs20 from "fs";
-import path22 from "path";
+import fs21 from "fs";
+import path23 from "path";
 import os13 from "os";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var SkillLoader = class _SkillLoader {
@@ -8116,8 +8741,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path22.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path22.join(os13.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path23.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path23.join(os13.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -8126,48 +8751,48 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path22.join(process.cwd(), "dist", "config", "skills");
+      return path23.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path22.resolve(p);
+      const abs = path23.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path22.dirname(fileURLToPath4(import.meta.url));
-      push(path22.join(bundleDir, "config", "skills"));
+      const bundleDir = path23.dirname(fileURLToPath4(import.meta.url));
+      push(path23.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path22.isAbsolute(argv1) && fs20.existsSync(argv1)) {
-          resolved = fs20.realpathSync(argv1);
-        } else if (!path22.isAbsolute(argv1)) {
-          resolved = path22.resolve(process.cwd(), argv1);
+        if (path23.isAbsolute(argv1) && fs21.existsSync(argv1)) {
+          resolved = fs21.realpathSync(argv1);
+        } else if (!path23.isAbsolute(argv1)) {
+          resolved = path23.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path22.dirname(resolved);
-        argvBundled = path22.join(scriptDir, "config", "skills");
+        const scriptDir = path23.dirname(resolved);
+        argvBundled = path23.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
     }
     for (const abs of candidates) {
-      if (fs20.existsSync(abs)) {
+      if (fs21.existsSync(abs)) {
         return abs;
       }
     }
     try {
-      return path22.join(path22.dirname(fileURLToPath4(import.meta.url)), "config", "skills");
+      return path23.join(path23.dirname(fileURLToPath4(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path22.join(os13.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path23.join(os13.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -8196,8 +8821,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path22.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path22.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path23.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path23.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -8205,20 +8830,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs20.existsSync(dir)) return [];
+    if (!fs21.existsSync(dir)) return [];
     try {
-      return fs20.readdirSync(dir).filter((d) => {
-        const fullPath = path22.join(dir, d);
-        return fs20.statSync(fullPath).isDirectory() && fs20.existsSync(path22.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path22.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs21.readdirSync(dir).filter((d) => {
+        const fullPath = path23.join(dir, d);
+        return fs21.statSync(fullPath).isDirectory() && fs21.existsSync(path23.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path23.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs20.existsSync(skillPath)) return null;
+    if (!fs21.existsSync(skillPath)) return null;
     try {
-      const raw = fs20.readFileSync(skillPath, "utf-8");
+      const raw = fs21.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -8240,12 +8865,12 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path22.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path22.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path22.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs20.existsSync(bundledPath);
-    const existsProject = fs20.existsSync(projectPath);
-    const existsGlobal = fs20.existsSync(globalPath);
+    const bundledPath = path23.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path23.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path23.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs21.existsSync(bundledPath);
+    const existsProject = fs21.existsSync(projectPath);
+    const existsGlobal = fs21.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -8284,9 +8909,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs20.readFileSync(skillPath, "utf-8");
+      const raw = fs21.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path22.dirname(skillPath);
+      const skillDir = path23.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -8295,22 +8920,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path22.join(skillDir, "references")),
-        scripts: this.scanAssets(path22.join(skillDir, "scripts"))
+        references: this.scanAssets(path23.join(skillDir, "references")),
+        scripts: this.scanAssets(path23.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs20.existsSync(dir)) return [];
+    if (!fs21.existsSync(dir)) return [];
     try {
-      return fs20.readdirSync(dir).filter((f) => {
-        const fp = path22.join(dir, f);
-        return fs20.statSync(fp).isFile();
+      return fs21.readdirSync(dir).filter((f) => {
+        const fp = path23.join(dir, f);
+        return fs21.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path22.resolve(dir, f)
+        path: path23.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -8367,10 +8992,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path22.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path22.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path22.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs20.existsSync(bundledPath) || fs20.existsSync(projectPath) || fs20.existsSync(globalPath);
+    const bundledPath = path23.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path23.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path23.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs21.existsSync(bundledPath) || fs21.existsSync(projectPath) || fs21.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -8402,8 +9027,8 @@ var SkillLoader = class _SkillLoader {
 };
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
-import fs21 from "fs";
-import path23 from "path";
+import fs22 from "fs";
+import path24 from "path";
 import { execSync as execSync2 } from "child_process";
 var LIMITS = {
   readme: 1e4,
@@ -8418,10 +9043,10 @@ var LIMITS = {
 };
 function safeReadFile(filePath, maxChars) {
   try {
-    if (!fs21.existsSync(filePath)) return null;
-    const st = fs21.statSync(filePath);
+    if (!fs22.existsSync(filePath)) return null;
+    const st = fs22.statSync(filePath);
     if (!st.isFile()) return null;
-    const raw = fs21.readFileSync(filePath, "utf8");
+    const raw = fs22.readFileSync(filePath, "utf8");
     if (raw.length <= maxChars) return raw;
     return `${raw.slice(0, maxChars)}
 
@@ -8432,7 +9057,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path23.join(cwd, name), LIMITS.readme);
+    const c = safeReadFile(path24.join(cwd, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -8440,14 +9065,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd) {
   const paths = [
-    path23.join(cwd, "BluMa.md"),
-    path23.join(cwd, "BLUMA.md"),
-    path23.join(cwd, ".bluma", "BluMa.md")
+    path24.join(cwd, "BluMa.md"),
+    path24.join(cwd, "BLUMA.md"),
+    path24.join(cwd, ".bluma", "BluMa.md")
   ];
   for (const p of paths) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path23.relative(cwd, p) || p;
+      const rel = path24.relative(cwd, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -8455,10 +9080,10 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd) {
-  const p = path23.join(cwd, "package.json");
+  const p = path24.join(cwd, "package.json");
   try {
-    if (!fs21.existsSync(p)) return null;
-    const pkg = JSON.parse(fs21.readFileSync(p, "utf8"));
+    if (!fs22.existsSync(p)) return null;
+    const pkg = JSON.parse(fs22.readFileSync(p, "utf8"));
     const scripts = pkg.scripts;
     let scriptKeys = "";
     if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
@@ -8491,7 +9116,7 @@ function summarizePackageJson(cwd) {
 }
 function topLevelListing(cwd) {
   try {
-    const names = fs21.readdirSync(cwd, { withFileTypes: true });
+    const names = fs22.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() ? "/" : ""}`);
@@ -8549,7 +9174,7 @@ function buildWorkspaceSnapshot(cwd) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path23.join(cwd, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path24.join(cwd, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -8567,15 +9192,15 @@ function buildWorkspaceSnapshot(cwd) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path23.join(cwd, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path24.join(cwd, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path23.join(cwd, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path24.join(cwd, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path23.join(cwd, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path24.join(cwd, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -8615,15 +9240,15 @@ init_runtime_config();
 
 // src/app/agent/runtime/plugin_registry.ts
 init_sandbox_policy();
-import fs22 from "fs";
+import fs23 from "fs";
 import os14 from "os";
-import path24 from "path";
+import path25 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path24.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path25.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path24.join(process.env.HOME || os14.homedir(), ".bluma", "plugins");
+  return path25.join(process.env.HOME || os14.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -8632,11 +9257,11 @@ function getPluginDirs() {
   };
 }
 function readManifest(manifestPath, fallbackName) {
-  if (!fs22.existsSync(manifestPath)) {
+  if (!fs23.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs22.readFileSync(manifestPath, "utf-8"));
+    const parsed = JSON.parse(fs23.readFileSync(manifestPath, "utf-8"));
     return {
       name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : fallbackName,
       description: typeof parsed.description === "string" ? parsed.description.trim() : void 0,
@@ -8649,22 +9274,22 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path24.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path24.join(pluginDir, "plugin.json")
+    path25.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path25.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
-    if (fs22.existsSync(candidate)) {
+    if (fs23.existsSync(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 function listFromDir(baseDir, source) {
-  if (!fs22.existsSync(baseDir)) {
+  if (!fs23.existsSync(baseDir)) {
     return [];
   }
-  return fs22.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path24.join(baseDir, entry.name);
+  return fs23.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+    const pluginDir = path25.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -8725,6 +9350,9 @@ Every message you send is to the **user**. Worker results are internal notificat
 | \`spawn_agent\` | Create a new worker |
 | \`wait_agent\` | Wait for worker completion |
 | \`list_agents\` | List active/completed workers |
+| \`send_message\` | **NEW:** Send follow-up to running worker (continue without re-spawn) |
+| \`list_mailbox_messages\` | **NEW:** Read messages from workers (progress, permission requests) |
+| \`signal_mailbox\` | **NEW:** Send ack/nack/progress signals |
 
 ### Tool contract (BluMa)
 
@@ -8732,7 +9360,7 @@ Every message you send is to the **user**. Worker results are internal notificat
 - Call \`wait_agent\` with \`{ "session_id": "<id>" }\`. Default \`timeout_ms\` is short (~30s); for audits, refactors, or test runs use a **large** \`timeout_ms\` (e.g. \`600000\`) or poll with \`list_agents\` if appropriate.
 - \`list_agents\` accepts optional \`parent_session_id\` and \`status\` filters.
 - **Parallelism:** In a single turn you may issue **multiple** \`spawn_agent\` calls back-to-back so independent workers start together; then \`wait_agent\` on each \`session_id\` (order as needed).
-- You do **not** receive XML or push notifications from workers \u2014 completion and payload come from \`wait_agent\` (and \`result\` inside that JSON when present).
+- **NEW: Bidirectional Communication** \u2014 Workers can now send messages to you via mailbox. Use \`list_mailbox_messages\` to read progress updates, permission requests, and results. Use \`send_message\` to continue a worker without re-spawning.
 
 ### When to call \`spawn_agent\`:
 
@@ -8897,14 +9525,323 @@ Fix for the null pointer in progress. Waiting for worker to complete tests and c
 function getCoordinatorSystemPrompt() {
   return COORDINATOR_SYSTEM_PROMPT;
 }
-function isCoordinatorModeEnabled() {
-  return process.env.BLUMA_COORDINATOR_MODE === "true";
+function isCoordinatorModeEnabled() {
+  return process.env.BLUMA_COORDINATOR_MODE === "true";
+}
+function enableCoordinatorMode() {
+  process.env.BLUMA_COORDINATOR_MODE = "true";
+}
+function disableCoordinatorMode() {
+  delete process.env.BLUMA_COORDINATOR_MODE;
+}
+
+// src/app/agent/utils/blumamd.ts
+import fs24 from "fs";
+import path26 from "path";
+import os15 from "os";
+var MEMORY_INSTRUCTION_PROMPT = "Instru\xE7\xF5es de mem\xF3ria do BluMa (BLUMA.md) est\xE3o abaixo. Siga estas instru\xE7\xF5es exatamente como escritas. Estas instru\xE7\xF5es OVERRIDE qualquer comportamento padr\xE3o.";
+var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".md",
+  ".txt",
+  ".text",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".csv",
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".js",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".py",
+  ".pyi",
+  ".pyw",
+  ".rb",
+  ".erb",
+  ".rake",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".c",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".h",
+  ".hpp",
+  ".hxx",
+  ".cs",
+  ".swift",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".bat",
+  ".cmd",
+  ".env",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".config",
+  ".properties",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".proto",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".ejs",
+  ".hbs",
+  ".pug",
+  ".jade",
+  ".php",
+  ".pl",
+  ".pm",
+  ".lua",
+  ".r",
+  ".R",
+  ".dart",
+  ".ex",
+  ".exs",
+  ".erl",
+  ".hrl",
+  ".clj",
+  ".cljs",
+  ".cljc",
+  ".edn",
+  ".hs",
+  ".lhs",
+  ".vim",
+  ".el",
+  ".scm",
+  ".ss",
+  ".cl",
+  ".lisp",
+  ".ml",
+  ".mli",
+  ".fs",
+  ".fsi",
+  ".fsx",
+  ".fsscript",
+  ".adb",
+  ".ads",
+  ".ada",
+  ".pas",
+  ".pp",
+  ".p",
+  ".tcl",
+  ".v",
+  ".sv",
+  ".svh",
+  ".vhdl",
+  ".cmake",
+  ".mk",
+  ".make",
+  ".dockerfile",
+  ".dockerignore",
+  ".gitignore",
+  ".gitattributes",
+  ".gitconfig",
+  ".editorconfig",
+  ".eslintrc",
+  ".prettierrc",
+  ".babelrc",
+  ".blumarc"
+]);
+function expandIncludePath(includePath, baseDir) {
+  const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
+  if (cleanPath.startsWith("~")) {
+    return path26.join(os15.homedir(), cleanPath.slice(1));
+  }
+  if (path26.isAbsolute(cleanPath)) {
+    return cleanPath;
+  }
+  return path26.resolve(baseDir, cleanPath);
+}
+function processIncludes(content, baseDir, processedFiles) {
+  const lines = content.split("\n");
+  const result = [];
+  for (const line of lines) {
+    const includeMatch = line.match(/^@\s*([^\s]+)/);
+    if (includeMatch) {
+      const includePath = expandIncludePath(includeMatch[1], baseDir);
+      const normalizedPath = path26.normalize(includePath);
+      if (processedFiles.has(normalizedPath)) {
+        result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
+        continue;
+      }
+      const ext = path26.extname(includePath).toLowerCase();
+      if (!TEXT_FILE_EXTENSIONS.has(ext)) {
+        result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
+        continue;
+      }
+      try {
+        const includedContent = fs24.readFileSync(includePath, "utf-8");
+        processedFiles.add(normalizedPath);
+        const processedContent = processIncludes(includedContent, path26.dirname(includePath), processedFiles);
+        result.push(`
+<!-- BEGIN INCLUDE ${includeMatch[1]} -->
+`);
+        result.push(processedContent);
+        result.push(`
+<!-- END INCLUDE ${includeMatch[1]} -->
+`);
+      } catch {
+        result.push(`<!-- Include not found: ${includeMatch[1]} -->`);
+      }
+    } else {
+      result.push(line);
+    }
+  }
+  return result.join("\n");
+}
+function readMemoryFile(filePath, type, priority) {
+  try {
+    const content = fs24.readFileSync(filePath, "utf-8");
+    const baseDir = path26.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path26.normalize(filePath)]);
+    const processedContent = processIncludes(content, baseDir, processedFiles);
+    return {
+      path: filePath,
+      content: processedContent.trim(),
+      type,
+      priority
+    };
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      console.error(`Error reading BLUMA.md file ${filePath}:`, error.message);
+    }
+    return null;
+  }
 }
-function enableCoordinatorMode() {
-  process.env.BLUMA_COORDINATOR_MODE = "true";
+function findGitRoot(startDir) {
+  let current = startDir;
+  while (current !== path26.dirname(current)) {
+    const gitPath = path26.join(current, ".git");
+    try {
+      if (fs24.existsSync(gitPath)) {
+        return current;
+      }
+    } catch {
+    }
+    current = path26.dirname(current);
+  }
+  return null;
 }
-function disableCoordinatorMode() {
-  delete process.env.BLUMA_COORDINATOR_MODE;
+function loadUserMemory() {
+  const files = [];
+  const homeDir = os15.homedir();
+  const userBlumaDir = path26.join(homeDir, ".bluma");
+  const userBlumaMd = path26.join(userBlumaDir, "BLUMA.md");
+  const userFile = readMemoryFile(userBlumaMd, "user", 2);
+  if (userFile) {
+    files.push(userFile);
+  }
+  const userRulesDir = path26.join(userBlumaDir, "rules");
+  if (fs24.existsSync(userRulesDir)) {
+    try {
+      const ruleFiles = fs24.readdirSync(userRulesDir).filter((f) => f.endsWith(".md")).sort();
+      for (const ruleFile of ruleFiles) {
+        const rulePath = path26.join(userRulesDir, ruleFile);
+        const rule = readMemoryFile(rulePath, "rule", 2);
+        if (rule) {
+          files.push(rule);
+        }
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function loadProjectMemory(cwd) {
+  const files = [];
+  const gitRoot = findGitRoot(cwd) || cwd;
+  const projectBlumaMd = path26.join(gitRoot, "BLUMA.md");
+  const projectFile = readMemoryFile(projectBlumaMd, "project", 3);
+  if (projectFile) {
+    files.push(projectFile);
+  }
+  const blumaDirBlumaMd = path26.join(gitRoot, ".bluma", "BLUMA.md");
+  const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "project", 3);
+  if (blumaDirFile) {
+    files.push(blumaDirFile);
+  }
+  const rulesDir = path26.join(gitRoot, ".bluma", "rules");
+  if (fs24.existsSync(rulesDir)) {
+    try {
+      const ruleFiles = fs24.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
+      for (const ruleFile of ruleFiles) {
+        const rulePath = path26.join(rulesDir, ruleFile);
+        const rule = readMemoryFile(rulePath, "rule", 3);
+        if (rule) {
+          files.push(rule);
+        }
+      }
+    } catch {
+    }
+  }
+  const localBlumaMd = path26.join(gitRoot, "BLUMA.local.md");
+  const localFile = readMemoryFile(localBlumaMd, "local", 4);
+  if (localFile) {
+    files.push(localFile);
+  }
+  return files;
+}
+function loadManagedMemory() {
+  const files = [];
+  const managedBlumaMd = "/etc/bluma/BLUMA.md";
+  const managedFile = readMemoryFile(managedBlumaMd, "managed", 1);
+  if (managedFile) {
+    files.push(managedFile);
+  }
+  return files;
+}
+function loadBlumaMd(cwd = process.cwd()) {
+  const managedFiles = loadManagedMemory();
+  const userFiles = loadUserMemory();
+  const projectFiles = loadProjectMemory(cwd);
+  const allFiles = [...managedFiles, ...userFiles, ...projectFiles];
+  allFiles.sort((a, b) => a.priority - b.priority);
+  const totalCharacters = allFiles.reduce((sum, f) => sum + f.content.length, 0);
+  const formattedContent = allFiles.map((f) => {
+    const header = `<!-- ${f.type.toUpperCase()}: ${f.path} -->`;
+    return `${header}
+${f.content}`;
+  }).join("\n\n");
+  return {
+    files: allFiles,
+    totalCharacters,
+    instructionPrompt: formattedContent.trim().length > 0 ? `${MEMORY_INSTRUCTION_PROMPT}
+
+${formattedContent}` : ""
+  };
+}
+function readBlumaMdForPrompt(cwd = process.cwd()) {
+  const config2 = loadBlumaMd(cwd);
+  if (config2.files.length === 0) {
+    return "(no BLUMA.md files found)";
+  }
+  const fileList = config2.files.map((f) => `- ${f.path} (${f.type})`).join("\n");
+  return `${config2.instructionPrompt}
+
+---
+Loaded ${config2.files.length} file(s), ${config2.totalCharacters.toLocaleString()} characters:
+${fileList}`;
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
@@ -8940,10 +9877,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs23.existsSync(path25.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs23.existsSync(path25.join(dir, "yarn.lock"))) return "yarn";
-    if (fs23.existsSync(path25.join(dir, "bun.lockb"))) return "bun";
-    if (fs23.existsSync(path25.join(dir, "package-lock.json"))) return "npm";
+    if (fs25.existsSync(path27.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs25.existsSync(path27.join(dir, "yarn.lock"))) return "yarn";
+    if (fs25.existsSync(path27.join(dir, "bun.lockb"))) return "bun";
+    if (fs25.existsSync(path27.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -8951,9 +9888,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs23.readdirSync(dir);
+    const files = fs25.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs23.readFileSync(path25.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs25.readFileSync(path27.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";
@@ -8972,9 +9909,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path25.join(dir, "package.json");
-    if (fs23.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs23.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path27.join(dir, "package.json");
+    if (fs25.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs25.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -8983,7 +9920,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs23.existsSync(path25.join(dir, "pytest.ini")) || fs23.existsSync(path25.join(dir, "conftest.py"))) return "pytest";
+    if (fs25.existsSync(path27.join(dir, "pytest.ini")) || fs25.existsSync(path27.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -8991,9 +9928,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path25.join(dir, "package.json");
-    if (fs23.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs23.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path27.join(dir, "package.json");
+    if (fs25.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs25.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -9142,7 +10079,7 @@ var SANDBOX_PROMPT_SUFFIX = `
 <sandbox_context>
 Sandbox mode ({sandbox_name}): input only via orchestrator JSON; no REPL/TUI/\`input()\`. Keep output deterministic and short.
 Stay inside the workspace: files + non-interactive \`shell_command\` + \`web_fetch\` / \`search_web\` if needed. Do not leave the job root; no host reconfiguration; never expose secrets.
-Final deliverables under \`./artifacts/\`; in the last \`message\` (\`result\`) list **absolute** paths in \`attachments[]\`. Remove temp files; do not attach generator scripts or junk.
+Final deliverables under \`./.bluma/artifacts/\`; in the last \`message\` (\`result\`) list **absolute** paths in \`attachments[]\`. Remove temp files; do not attach generator scripts or junk.
 **Secrets:** never run commands whose purpose is dumping environment (\`env\`, \`printenv\`, \`os.environ\`, etc.); never print *_KEY/*_TOKEN/*_SECRET or full env dumps. Refuse such requests.
 </sandbox_context>
 `;
@@ -9151,12 +10088,12 @@ function getUnifiedSystemPrompt(availableSkills) {
   const runtimeConfig = getRuntimeConfig();
   const availablePlugins = listPlugins();
   const env = {
-    os_type: os15.type(),
-    os_version: os15.release(),
-    architecture: os15.arch(),
+    os_type: os16.type(),
+    os_version: os16.release(),
+    architecture: os16.arch(),
     workdir: cwd,
     shell_type: process.env.SHELL || process.env.COMSPEC || "unknown",
-    username: os15.userInfo().username,
+    username: os16.userInfo().username,
     current_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     is_git_repo: isGitRepo(cwd) ? "yes" : "no",
@@ -9209,13 +10146,20 @@ Runtime extensions (not skills); use when relevant; do not invent names.
 <coding_memory_snapshot>
 ${memorySnapshot.trim().length > 0 ? memorySnapshot : "(empty \u2014 use coding_memory: add | list | search)"}
 </coding_memory_snapshot>
+`;
+  const blumaMdContent = readBlumaMdForPrompt(cwd);
+  prompt += `
+
+<bluma_md>
+${blumaMdContent}
+</bluma_md>
 `;
   return prompt;
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path25.join(dir, ".git");
-    return fs23.existsSync(gitPath) && fs23.lstatSync(gitPath).isDirectory();
+    const gitPath = path27.join(dir, ".git");
+    return fs25.existsSync(gitPath) && fs25.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -9432,16 +10376,22 @@ async function createApiContextWindow(fullHistory, currentAnchor, compressedTurn
   let messages = buildContextMessages(systemMessages, anchor, pendingFlat, recentFlat);
   let tokens = countTokens(messages);
   while (tokens >= thresholdTokens && pendingSlices.length > 0) {
-    anchor = await compressToAnchor(
-      pendingFlat,
-      anchor,
-      llmService,
-      userContext,
-      pendingSlices.length
-    );
-    sliceCount = recentStart;
-    pendingSlices = [];
-    pendingFlat = [];
+    try {
+      anchor = await compressToAnchor(
+        pendingFlat,
+        anchor,
+        llmService,
+        userContext,
+        pendingSlices.length
+      );
+      sliceCount = recentStart;
+      pendingSlices = [];
+      pendingFlat = [];
+    } catch (compressError) {
+      console.warn("[ContextManager] Compression failed, keeping uncompressed history:", compressError?.message || compressError);
+      pendingSlices = [];
+      pendingFlat = [];
+    }
     messages = buildContextMessages(systemMessages, anchor, pendingFlat, recentFlat);
     tokens = countTokens(messages);
   }
@@ -9454,7 +10404,7 @@ async function createApiContextWindow(fullHistory, currentAnchor, compressedTurn
 
 // src/app/agent/core/llm/llm.ts
 init_runtime_config();
-import os16 from "os";
+import os17 from "os";
 import OpenAI from "openai";
 function defaultBlumaUserContextInput(sessionId, userMessage) {
   const msg = String(userMessage || "").slice(0, 300);
@@ -9471,7 +10421,7 @@ function defaultBlumaUserContextInput(sessionId, userMessage) {
 }
 function getPreferredMacAddress() {
   try {
-    const ifaces = os16.networkInterfaces();
+    const ifaces = os17.networkInterfaces();
     for (const name of Object.keys(ifaces)) {
       const addrs = ifaces[name];
       if (!addrs) continue;
@@ -9486,7 +10436,7 @@ function getPreferredMacAddress() {
   } catch {
   }
   try {
-    return `host:${os16.hostname()}`;
+    return `host:${os17.hostname()}`;
   } catch {
     return "unknown";
   }
@@ -9496,7 +10446,7 @@ function defaultInteractiveCliUserContextInput(sessionId, userMessage) {
   const machineId = getPreferredMacAddress();
   let userName = null;
   try {
-    userName = os16.userInfo().username || null;
+    userName = os17.userInfo().username || null;
   } catch {
     userName = null;
   }
@@ -9943,8 +10893,8 @@ function classifyToolInvocation(input) {
 
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
-import fs24 from "fs";
-import path26 from "path";
+import fs26 from "fs";
+import path28 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -9955,7 +10905,7 @@ var cache2 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path26.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path28.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -9974,8 +10924,8 @@ function ensureLoaded2() {
     return cache2;
   }
   try {
-    if (fs24.existsSync(statePath)) {
-      const parsed = JSON.parse(fs24.readFileSync(statePath, "utf-8"));
+    if (fs26.existsSync(statePath)) {
+      const parsed = JSON.parse(fs26.readFileSync(statePath, "utf-8"));
       cache2 = {
         enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : DEFAULT_STATE.enabled,
         maxEvents: typeof parsed.maxEvents === "number" && Number.isFinite(parsed.maxEvents) && parsed.maxEvents > 0 ? Math.floor(parsed.maxEvents) : DEFAULT_STATE.maxEvents,
@@ -10001,9 +10951,9 @@ function ensureLoaded2() {
 }
 function persist2(state) {
   const statePath = getStatePath();
-  fs24.mkdirSync(path26.dirname(statePath), { recursive: true });
+  fs26.mkdirSync(path28.dirname(statePath), { recursive: true });
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs24.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+  fs26.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
   cache2 = state;
   cachePath2 = statePath;
 }
@@ -10100,11 +11050,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/natives/coding_memory_consolidate.ts
-import * as fs25 from "fs";
-import * as path27 from "path";
-import os17 from "os";
+import * as fs27 from "fs";
+import * as path29 from "path";
+import os18 from "os";
 function memoryPath() {
-  return path27.join(process.env.HOME || os17.homedir(), ".bluma", "coding_memory.json");
+  return path29.join(process.env.HOME || os18.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -10114,18 +11064,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath();
-  if (!fs25.existsSync(p)) {
+  if (!fs27.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs25.copyFileSync(p, bak);
+    fs27.copyFileSync(p, bak);
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `backup failed: ${e.message}` };
   }
   let data;
   try {
-    data = JSON.parse(fs25.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs27.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -10160,7 +11110,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs25.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs27.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -10353,7 +11303,7 @@ var BluMaAgent = class {
     this.isInterrupted = false;
     this.factorRouterTurnClosed = false;
     const inputText = String(userInput.content || "").trim();
-    const turnId = uuidv44();
+    const turnId = uuidv45();
     this.activeTurnContext = {
       ...userContextInput,
       turnId,
@@ -10755,7 +11705,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path28.basename(toolArgs.file_path);
+      const filename = path30.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}`;
@@ -10791,6 +11741,18 @@ ${editData.error.display}`;
         this.eventBus.emit("backend_message", { type: "info", message: "Task Canceled." });
         return;
       }
+      const mailboxUpdate = await this._pollWorkerMailbox();
+      if (mailboxUpdate && mailboxUpdate.followUp) {
+        this.history.push({
+          role: "user",
+          content: mailboxUpdate.followUp.message
+        });
+        this.persistSession();
+        this.eventBus.emit("backend_message", {
+          type: "info",
+          message: `Received follow-up from coordinator (priority: ${mailboxUpdate.followUp.priority})`
+        });
+      }
       const { messages: contextWindow, newAnchor, newCompressedTurnSliceCount } = await createApiContextWindow(
         this.history,
         this.sessionAnchor,
@@ -10855,7 +11817,6 @@ ${editData.error.display}`;
   }
   async _handleStreamingResponse(contextWindow) {
     const llmService = this.llm;
-    this.eventBus.emit("action_status", { action: "Thinking" });
     let accumulatedContent = "";
     let toolCalls;
     let hasEmittedStart = false;
@@ -10887,8 +11848,15 @@ ${editData.error.display}`;
         accumulatedContent += chunk.delta;
         this.eventBus.emit("stream_chunk", { delta: chunk.delta });
       }
-      if (chunk.tool_calls) {
+      if (chunk.tool_calls && chunk.tool_calls.length > 0) {
         toolCalls = chunk.tool_calls;
+        for (const tc of toolCalls || []) {
+          const toolName = tc?.function?.name ?? "";
+          const argsRaw = tc?.function?.arguments ?? "{}";
+          if (toolName) {
+            this.eventBus.emit("tool_stream_start", { toolName, argsRaw });
+          }
+        }
       }
     }
     const omitAssistantFlush = Array.isArray(toolCalls) && toolCalls.some((tc) => String(tc?.function?.name ?? "").includes("message"));
@@ -11048,55 +12016,291 @@ ${editData.error.display}`;
     } catch {
     }
   }
+  /**
+   * WORKER: Poll mailbox para checkar follow-ups do coordinator
+   * Retorna null se não há novas mensagens ou se não é um worker
+   */
+  async _pollWorkerMailbox() {
+    if (!process.env.BLUMA_PARENT_SESSION_ID) {
+      return null;
+    }
+    try {
+      const { pollMailbox: pollMailbox2 } = await Promise.resolve().then(() => (init_poll_mailbox(), poll_mailbox_exports));
+      const result = await pollMailbox2({
+        timeout: 0,
+        // Non-blocking
+        pollInterval: 500,
+        types: ["follow_up", "cancel_request", "permission_response"],
+        includeSignals: false
+      });
+      if (!result.success || !result.hasNewMessages) {
+        return null;
+      }
+      return {
+        followUp: result.followUp ? {
+          message: result.followUp.message,
+          priority: result.followUp.priority
+        } : void 0,
+        cancelRequested: result.cancelRequested
+      };
+    } catch (error) {
+      return null;
+    }
+  }
 };
 
-// src/app/agent/subagents/registry.ts
-var subAgentRegistry = {};
-function registerSubAgent(subAgent) {
-  for (const cap of subAgent.capabilities) {
-    subAgentRegistry[cap] = subAgent;
+// src/app/agent/subagents/registry.ts
+var subAgentRegistry = {};
+function registerSubAgent(subAgent) {
+  for (const cap of subAgent.capabilities) {
+    subAgentRegistry[cap] = subAgent;
+  }
+}
+function getSubAgentByCommand(cmd) {
+  return subAgentRegistry[cmd];
+}
+
+// src/app/agent/subagents/init/init_subagent.ts
+import { v4 as uuidv47 } from "uuid";
+
+// src/app/agent/subagents/base_llm_subagent.ts
+import { v4 as uuidv46 } from "uuid";
+
+// src/app/agent/subagents/init/init_system_prompt.ts
+import os19 from "os";
+var SYSTEM_PROMPT2 = `
+
+### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
+You extend the BluMa multi-agent architecture and handle the project bootstrapping/init workflow: scanning the repository, inferring stack, and generating a high-quality BluMa.md with actionable project context.
+
+---
+
+## BEHAVIORAL RULES
+
+- Identity:
+  You are BluMa InitSubAgent. Maintain professionalism and technical language.
+
+- Communication:
+  ALL messages must be sent via 'message'.
+  No direct text replies to the user.
+
+- Task Completion:
+  When the init task is completed, immediately invoke 'agent_end_turn' without user permissions.
+
+- Tool Rules:
+  Never make parallel tool calls.
+  Only use the defined tools with their exact names.
+
+- Autonomy:
+  Act 100% autonomously.
+  Do not ask for formatting preferences.
+  Use the notebook for internal reasoning.
+
+
+### CRITICAL COMMUNICATION PROTOCOL
+- Only tool_calls are allowed for assistant replies. Never include a "content" field.
+- Always use tools to respond, retrieve data, compute or transform. Await a valid tool response before any final message.
+- Zero tolerance for protocol violations.
+
+<current_system_environment>
+- Operating System: {os_type} ({os_version})
+- Architecture: {architecture}
+- Current Working Directory: {workdir}
+- Shell: {shell_type}
+- User: {username}
+- Current Date: {current_date}
+- Timezone: {timezone}
+- Locale: {locale}
+</current_system_environment>
+
+<message_rules>
+- Communicate with user's via message tools instead of direct text responses
+- Reply immediately to new user messages before other operations
+- First reply must be brief, only confirming receipt without specific solutions
+- Notify user's with brief explanation when changing methods or strategies
+- Message tools are divided into notify (non-blocking, no reply needed) and ask (blocking)
+- Actively use notify for progress updates, reserve ask for essential needs to avoid blocking
+- Must message user's with results and deliverables before upon task completion 'agent_end_turn'
+</message_rules>
+
+<reasoning_rules>
+# YOUR THINKING ON A NOTEBOOK - MANDATORY USE
+CRITICAL: Your laptop (reasoning_nootebook) is your ORGANIZED MIND
+## IMPORTANT
+## NEVER PUT CHECKLISTS OR STEPS IN THE THOUGHT TEXT
+## ALWAYS USE A NOTEBOOK (Always for):
+- ANY task
+- Before starting userelopment (plan first!)
+- Projects with multiple files (organize the structure)
+- Debugging sessions (monitor discoveries)
+- Extensive refactoring (map the changes)
+- Architectural decisions (think through the options)
+
+## HOW TO USE A NOTEBOOK:
+1. Start with reasoning_nootebook
+2. Break the task down into logical steps
+3. Plan the approach \u2013 Which files? What changes? What order?
+4. Track progress \u2013 Check off completed steps
+5. Write down decisions \u2013 Why did you choose this approach?
+6. Update continuously \u2013 Keep the notebook up to date
+
+## THE NOTEBOOK PREVENTS:
+- Acting "outside the box"
+- Forgetting task requirements
+- Losing control of complex workflows
+- Making unplanned changes
+- Ineffective approaches
+- Working without a clear roadmap
+- Jumping between unrelated subtasks
+
+Important rule:
+Do not include future steps/to-dos in thought; put them strictly in to_do, using the mandated checklist markers.
+
+- to_do: Checklist list of high-level upcoming tasks.
+  Format is mandatory:
+  - "\u{1F5F8}" \u2192 for tasks not yet done (pending)
+  - "[ ]" \u2192 for tasks already completed
+</reasoning_rules>
+
+<edit_tool_rules>  
+- Use this tool to perform precise text replacements inside files based on exact literal matches.
+- Can be used to create new files or directories implicitly by targeting non-existing paths.
+- Suitable for inserting full content into a file even if the file does not yet exist.
+- Shell access is not required for file or directory creation when using this tool.
+- Always prefer this tool over shell_command when performing structured edits or creating files with specific content.
+- Ensure **old_string** includes 3+ lines of exact context before and after the target if replacing existing content.
+- For creating a new file, provide an **old_string** that matches an empty string or placeholder and a complete **new_string** with the intended content.
+- When generating or modifying todo.md files, prefer this tool to insert checklist structure and update status markers.
+- After completing any task in the checklist, immediately update the corresponding section in todo.md using this tool.
+- Reconstruct the entire file from task planning context if todo.md becomes outdated or inconsistent.
+- Track all progress related to planning and execution inside todo.md using text replacement only.
+</edit_tool_rules>
+
+
+<agent_end_turn>
+  This tool is mandatory.
+  You must use it to inform usereloper {username} that the task has been completed and that there are no further pending actions, in accordance with the objectives defined for the task.
+</agent_end_turn>
+
+### Tool Naming Policy
+- Use plain, unmodified, lowercase tool names
+- No special characters, spaces, or version suffixes
+
+Rule Summary:
+- Use only a\u2013z, 0\u20139, and underscores (_)
+- Do not append suffixes like :0, :v2, etc.
+- Tool names must be static and predictable
+
+
+## INIT SUBAGENT OBJECTIVE
+- Map repository structure and significant files.
+- Infer tech stack (frameworks, package managers, languages, build/test tools).
+- Identify entry points, configuration files, and scripts.
+- Produce BluMa.md with:
+  - Project overview and goals inferred from code/docs
+  - Tech stack summary
+  - Directory map (high-level)
+  - Key configs and scripts
+  - Known tasks or next steps for agents
+- Always use tools (ls, readLines, count_lines, shell_command, edit_tool) to gather evidence before writing.
+- Never invent file content. Read files via tools to confirm.
+
+## OUTPUT
+- Emit 'backend_message' events through tools only (message) for progress updates.
+- Before writing BluMa.md, propose structure via message and proceed using edit_tool.
+- If an irreversible operation is needed (e.g., overwriting an existing BluMa.md), issue 'confirmation_request' unless user policy indicates auto-approval.
+- Never send or present draft versions of BluMa.md. Only produce and deliver the final, validated BluMa.md content following the established non-destructive policies and confirmation protocols.
+- On successful generation of BluMa.md, emit 'done' with status 'completed' and call agent_end_turn.
+
+## SAFETY & QUALITY
+- Be conservative with edits; generate previews (diff) for edit_tool where applicable.
+- Keep file system operations idempotent and explicit.
+- Prefer performance-efficient scans (avoid reading entire large binaries).
+- Respect test environment constraints.
+
+## EXEMPLAR FLOW (GUIDELINE)
+1) Explore repo: ls + targeted readLines for key files (package.json, tsconfig.json, README, etc.)
+2) Synthesize stack and structure with citations of evidence (file paths) in the notebook
+3) Draft BluMa.md structure (message)
+4) Write BluMa.md via edit_tool
+5) Announce completion and agent_end_turn
+
+
+`;
+function getInitPrompt() {
+  const now2 = /* @__PURE__ */ new Date();
+  const collectedData = {
+    os_type: os19.type(),
+    os_version: os19.release(),
+    architecture: os19.arch(),
+    workdir: process.cwd(),
+    shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
+    username: os19.userInfo().username || "Unknown",
+    current_date: now2.toISOString().split("T")[0],
+    // Formato YYYY-MM-DD
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
+    locale: process.env.LANG || process.env.LC_ALL || "Unknown"
+  };
+  const finalEnv = {
+    os_type: "Unknown",
+    os_version: "Unknown",
+    workdir: "Unknown",
+    shell_type: "Unknown",
+    username: "Unknown",
+    architecture: "Unknown",
+    current_date: "Unknown",
+    timezone: "Unknown",
+    locale: "Unknown",
+    ...collectedData
+    // Os dados coletados sobrescrevem os padrões
+  };
+  let formattedPrompt = SYSTEM_PROMPT2;
+  for (const key in finalEnv) {
+    const placeholder = `{${key}}`;
+    formattedPrompt = formattedPrompt.replace(new RegExp(placeholder, "g"), finalEnv[key]);
   }
-}
-function getSubAgentByCommand(cmd) {
-  return subAgentRegistry[cmd];
+  return formattedPrompt;
 }
 
-// src/app/agent/subagents/init/init_subagent.ts
-import { v4 as uuidv46 } from "uuid";
-
-// src/app/agent/subagents/base_llm_subagent.ts
-import { v4 as uuidv45 } from "uuid";
-
-// src/app/agent/subagents/init/init_system_prompt.ts
-import os18 from "os";
-var SYSTEM_PROMPT2 = `
+// src/app/agent/subagents/worker_system_prompt.ts
+import os20 from "os";
+var WORKER_SYSTEM_PROMPT = `
 
-### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
-You extend the BluMa multi-agent architecture and handle the project bootstrapping/init workflow: scanning the repository, inferring stack, and generating a high-quality BluMa.md with actionable project context.
+### YOU ARE BluMa CLI \u2014 WORKER AGENT \u2014 AUTONOMOUS SOFTWARE ENGINEERING SPECIALIST @ NOMADENGENUITY
+You are a worker agent spawned by the BluMa Coordinator to execute specific software engineering tasks.
 
 ---
 
 ## BEHAVIORAL RULES
 
-- Identity:
-  You are BluMa InitSubAgent. Maintain professionalism and technical language.
-
-- Communication:
-  ALL messages must be sent via 'message'.
-  No direct text replies to the user.
-
-- Task Completion:
-  When the init task is completed, immediately invoke 'agent_end_turn' without user permissions.
-
-- Tool Rules:
-  Never make parallel tool calls.
-  Only use the defined tools with their exact names.
-
-- Autonomy:
-  Act 100% autonomously.
-  Do not ask for formatting preferences.
-  Use the notebook for internal reasoning.
+- **Identity:**
+  You are a BluMa Worker Agent. You execute tasks delegated by the Coordinator.
+  Maintain professionalism and technical excellence.
+
+- **Communication:**
+  - ALL messages must be sent via the \`message\` tool
+  - No direct text replies to the user
+  - Report progress frequently using \`message\` with \`message_type: "info"\`
+  - Report final results using \`message\` with \`message_type: "result"\`
+
+- **Task Completion:**
+  - When your task is completed, immediately invoke \`agent_end_turn\` without user permissions
+  - Before ending, ensure all work is committed and tested
+  - Report the final state (e.g., commit hash, test results, file paths)
+
+- **Tool Rules:**
+  - Never make parallel tool calls
+  - Only use the defined tools with their exact names
+  - Read before editing (\`read_file_lines\`, \`grep_search\`, \`ls_tool\`)
+  - Verify changes with tests or typechecks when applicable
+
+- **Autonomy:**
+  - Act 100% autonomously within your task scope
+  - Do not ask for clarification unless the task is fundamentally blocked
+  - Use the notebook for internal reasoning and planning
+  - If you encounter errors, attempt to resolve them before reporting failure
 
+---
 
 ### CRITICAL COMMUNICATION PROTOCOL
 - Only tool_calls are allowed for assistant replies. Never include a "content" field.
@@ -11115,30 +12319,31 @@ You extend the BluMa multi-agent architecture and handle the project bootstrappi
 </current_system_environment>
 
 <message_rules>
-- Communicate with user's via message tools instead of direct text responses
+- Communicate with the user via \`message\` tool instead of direct text responses
 - Reply immediately to new user messages before other operations
-- First reply must be brief, only confirming receipt without specific solutions
-- Notify user's with brief explanation when changing methods or strategies
+- First reply must be brief, only confirming receipt of the task
+- Notify user with brief explanation when changing methods or strategies
 - Message tools are divided into notify (non-blocking, no reply needed) and ask (blocking)
 - Actively use notify for progress updates, reserve ask for essential needs to avoid blocking
-- Must message user's with results and deliverables before upon task completion 'agent_end_turn'
+- Must message user with results and deliverables before calling \`agent_end_turn\`
 </message_rules>
 
 <reasoning_rules>
 # YOUR THINKING ON A NOTEBOOK - MANDATORY USE
-CRITICAL: Your laptop (reasoning_nootebook) is your ORGANIZED MIND
+CRITICAL: Your notebook (reasoning_notebook) is your ORGANIZED MIND
+
 ## IMPORTANT
-## NEVER PUT CHECKLISTS OR STEPS IN THE THOUGHT TEXT
-## ALWAYS USE A NOTEBOOK (Always for):
-- ANY task
-- Before starting userelopment (plan first!)
-- Projects with multiple files (organize the structure)
-- Debugging sessions (monitor discoveries)
-- Extensive refactoring (map the changes)
-- Architectural decisions (think through the options)
+- NEVER PUT CHECKLISTS OR STEPS IN THE THOUGHT TEXT
+- ALWAYS USE A NOTEBOOK (Always for):
+  - ANY task
+  - Before starting development (plan first!)
+  - Projects with multiple files (organize the structure)
+  - Debugging sessions (track discoveries)
+  - Extensive refactoring (map the changes)
+  - Architectural decisions (think through the options)
 
 ## HOW TO USE A NOTEBOOK:
-1. Start with reasoning_nootebook
+1. Start with reasoning_notebook
 2. Break the task down into logical steps
 3. Plan the approach \u2013 Which files? What changes? What order?
 4. Track progress \u2013 Check off completed steps
@@ -11160,7 +12365,7 @@ Do not include future steps/to-dos in thought; put them strictly in to_do, using
 - to_do: Checklist list of high-level upcoming tasks.
   Format is mandatory:
   - "\u{1F5F8}" \u2192 for tasks not yet done (pending)
-  - "[ ]" \u2192 for tasks already completed
+  - "[\u2713]" \u2192 for tasks already completed
 </reasoning_rules>
 
 <edit_tool_rules>  
@@ -11177,10 +12382,9 @@ Do not include future steps/to-dos in thought; put them strictly in to_do, using
 - Track all progress related to planning and execution inside todo.md using text replacement only.
 </edit_tool_rules>
 
-
 <agent_end_turn>
   This tool is mandatory.
-  You must use it to inform usereloper {username} that the task has been completed and that there are no further pending actions, in accordance with the objectives defined for the task.
+  You must use it to inform the user that the task has been completed and that there are no further pending actions, in accordance with the objectives defined for the task.
 </agent_end_turn>
 
 ### Tool Naming Policy
@@ -11192,53 +12396,121 @@ Rule Summary:
 - Do not append suffixes like :0, :v2, etc.
 - Tool names must be static and predictable
 
+---
 
-## INIT SUBAGENT OBJECTIVE
-- Map repository structure and significant files.
-- Infer tech stack (frameworks, package managers, languages, build/test tools).
-- Identify entry points, configuration files, and scripts.
-- Produce BluMa.md with:
-  - Project overview and goals inferred from code/docs
-  - Tech stack summary
-  - Directory map (high-level)
-  - Key configs and scripts
-  - Known tasks or next steps for agents
-- Always use tools (ls, readLines, count_lines, shell_command, edit_tool) to gather evidence before writing.
-- Never invent file content. Read files via tools to confirm.
+## WORKER AGENT OBJECTIVE
+
+You receive a specific task from the Coordinator. Your job is to:
+
+1. **Understand the task** - Read the task description carefully
+2. **Plan your approach** - Use the notebook to break down the work
+3. **Execute autonomously** - Use tools to gather evidence, make changes, and verify
+4. **Report progress** - Keep the Coordinator informed via \`message\` tool
+5. **Verify your work** - Run tests, typechecks, or other validation
+6. **Complete and report** - Call \`agent_end_turn\` with final results
+
+### Task Types
+
+You may be assigned different types of work:
+
+**Research Tasks:**
+- Investigate codebase structure
+- Find specific files or patterns
+- Analyze architectural decisions
+- Report findings with file paths, line numbers, and evidence
+- Do NOT modify files unless explicitly instructed
+
+**Implementation Tasks:**
+- Make targeted code changes
+- Follow best practices and existing patterns
+- Run relevant tests and typechecks
+- Commit changes and report the commit hash
+- Fix root causes, not symptoms
+
+**Verification Tasks:**
+- Test changes made by other workers
+- Run tests with the feature enabled
+- Investigate failures - don't dismiss as unrelated
+- Prove the code works, don't just confirm it exists
+- Report specific evidence (test output, error messages)
+
+**Refactoring Tasks:**
+- Improve code structure without changing behavior
+- Maintain existing functionality
+- Update tests if needed
+- Verify with tests and typechecks
+
+---
 
 ## OUTPUT
-- Emit 'backend_message' events through tools only (message) for progress updates.
-- Before writing BluMa.md, propose structure via message and proceed using edit_tool.
-- If an irreversible operation is needed (e.g., overwriting an existing BluMa.md), issue 'confirmation_request' unless user policy indicates auto-approval.
-- Never send or present draft versions of BluMa.md. Only produce and deliver the final, validated BluMa.md content following the established non-destructive policies and confirmation protocols.
-- On successful generation of BluMa.md, emit 'done' with status 'completed' and call agent_end_turn.
+
+- Emit \`backend_message\` events through tools only (\`message\`) for progress updates
+- Before making irreversible changes, ensure you have proper authorization or the runtime allows auto-approval
+- Never present draft versions - only produce and deliver final, validated results
+- On successful task completion, emit 'done' with status 'completed' and call \`agent_end_turn\`
+
+---
 
 ## SAFETY & QUALITY
-- Be conservative with edits; generate previews (diff) for edit_tool where applicable.
-- Keep file system operations idempotent and explicit.
-- Prefer performance-efficient scans (avoid reading entire large binaries).
-- Respect test environment constraints.
+
+- Be conservative with edits; generate previews (diff) for \`edit_tool\` where applicable
+- Keep file system operations idempotent and explicit
+- Prefer performance-efficient scans (avoid reading entire large binaries)
+- Respect test environment constraints
+- Never expose secrets or run commands that dump environment variables
+
+---
 
 ## EXEMPLAR FLOW (GUIDELINE)
-1) Explore repo: ls + targeted readLines for key files (package.json, tsconfig.json, README, etc.)
-2) Synthesize stack and structure with citations of evidence (file paths) in the notebook
-3) Draft BluMa.md structure (message)
-4) Write BluMa.md via edit_tool
-5) Announce completion and agent_end_turn
 
+### Research Task Example:
+1. Acknowledge task via \`message\` (info)
+2. Use \`ls_tool\`, \`read_file_lines\`, \`grep_search\` to gather evidence
+3. Track findings in notebook
+4. Report findings via \`message\` (result) with specific file paths and line numbers
+5. Call \`agent_end_turn\`
+
+### Implementation Task Example:
+1. Acknowledge task via \`message\` (info)
+2. Read relevant files to understand current state
+3. Plan changes in notebook
+4. Use \`edit_tool\` to make changes
+5. Run tests via \`shell_command\`
+6. Fix any failures
+7. Commit changes via \`shell_command\` (git commit)
+8. Report commit hash via \`message\` (result)
+9. Call \`agent_end_turn\`
+
+### Verification Task Example:
+1. Acknowledge task via \`message\` (info)
+2. Run tests via \`shell_command\`
+3. Investigate any failures deeply
+4. Report specific evidence (pass/fail, error messages)
+5. Call \`agent_end_turn\` with verdict
+
+---
+
+## CRITICAL REMINDERS
+
+- **You cannot see the Coordinator's conversation** - Your task prompt must be self-contained
+- **Work autonomously** - Don't ask for clarification unless fundamentally blocked
+- **Verify before reporting done** - Run tests, check types, ensure code works
+- **Report specific evidence** - File paths, line numbers, commit hashes, test output
+- **Use the notebook** - Plan, track progress, record decisions
+- **Communicate progress** - Use \`message\` tool frequently with \`message_type: "info"\`
+- **End properly** - Call \`agent_end_turn\` when task is complete
 
 `;
-function getInitPrompt() {
+function getWorkerPrompt() {
   const now2 = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os18.type(),
-    os_version: os18.release(),
-    architecture: os18.arch(),
+    os_type: os20.type(),
+    os_version: os20.release(),
+    architecture: os20.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os18.userInfo().username || "Unknown",
+    username: os20.userInfo().username || "Unknown",
     current_date: now2.toISOString().split("T")[0],
-    // Formato YYYY-MM-DD
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
     locale: process.env.LANG || process.env.LC_ALL || "Unknown"
   };
@@ -11253,9 +12525,8 @@ function getInitPrompt() {
     timezone: "Unknown",
     locale: "Unknown",
     ...collectedData
-    // Os dados coletados sobrescrevem os padrões
   };
-  let formattedPrompt = SYSTEM_PROMPT2;
+  let formattedPrompt = WORKER_SYSTEM_PROMPT;
   for (const key in finalEnv) {
     const placeholder = `{${key}}`;
     formattedPrompt = formattedPrompt.replace(new RegExp(placeholder, "g"), finalEnv[key]);
@@ -11281,7 +12552,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 = uuidv45();
+    const turnId = uuidv46();
     this.subagentTurnContext = {
       ...base,
       turnId,
@@ -11296,7 +12567,7 @@ var BaseLLMSubAgent = class {
     const [sessionFile, history] = await loadOrcreateSession(sessionId);
     this.sessionFile = sessionFile;
     this.history = history || [];
-    const systemPromptContent = getInitPrompt();
+    const systemPromptContent = this.id === "init" ? getInitPrompt() : getWorkerPrompt();
     if (this.history.length === 0) {
       this.history.push({
         role: "system",
@@ -11449,7 +12720,7 @@ var InitAgentImpl = class extends BaseLLMSubAgent {
     const base = ctx.blumaUserContextInput ?? defaultBlumaUserContextInput(`subagent:${this.id}`, preview);
     this.subagentTurnContext = {
       ...base,
-      turnId: uuidv46(),
+      turnId: uuidv47(),
       sessionId: base.sessionId || `subagent:${this.id}`
     };
     const seed = `
@@ -11543,14 +12814,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path33, handler) {
-    this.routeHandlers.set(path33, handler);
+  registerRoute(path35, handler) {
+    this.routeHandlers.set(path35, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext } = payload;
-    for (const [path33, handler] of this.routeHandlers) {
-      if (inputText === path33 || inputText.startsWith(`${path33} `)) {
+    for (const [path35, handler] of this.routeHandlers) {
+      if (inputText === path35 || inputText.startsWith(`${path35} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -11559,13 +12830,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path29 from "path";
+import path31 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function loadPluginsAtStartup() {
   for (const p of listPlugins()) {
     const entry = p.manifest.entry?.trim();
     if (!entry) continue;
-    const abs = path29.resolve(p.root, entry);
+    const abs = path31.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -11586,7 +12857,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path30.join(os19.homedir(), ".bluma", ".env");
+var globalEnvPath = path32.join(os21.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -11820,6 +13091,162 @@ function formatTurnDurationMs(ms) {
   return `${min}min \xB7 ${sec}s`;
 }
 
+// src/app/ui/utils/toolActionLabels.ts
+function parseArgsRecord2(args) {
+  if (args == null) return {};
+  if (typeof args === "string") {
+    try {
+      return JSON.parse(args);
+    } catch {
+      return {};
+    }
+  }
+  if (typeof args === "object") {
+    return args;
+  }
+  return {};
+}
+function getToolActionLabel(toolName, args) {
+  const p = parseArgsRecord2(args);
+  switch (toolName) {
+    case "shell_command":
+    case "run_command": {
+      const cmd = typeof p.command === "string" ? p.command : "";
+      const truncated = cmd.length > 40 ? `${cmd.slice(0, 40)}\u2026` : cmd;
+      return truncated ? `Executing: ${truncated}` : "Executing command";
+    }
+    case "command_status":
+      return "Checking command status";
+    case "send_command_input":
+      return "Sending input to command";
+    case "kill_command":
+      return "Terminating command";
+    case "read_file_lines": {
+      const filepath = typeof p.filepath === "string" ? p.filepath : "";
+      const file = filepath.split("/").pop() || filepath;
+      return file ? `Reading: ${file}` : "Reading file";
+    }
+    case "count_file_lines": {
+      const filepath = typeof p.filepath === "string" ? p.filepath : "";
+      const file = filepath.split("/").pop() || filepath;
+      return file ? `Counting: ${file}` : "Counting lines";
+    }
+    case "edit_tool": {
+      const edits = p.edits;
+      const count = Array.isArray(edits) ? edits.length : 1;
+      const filepath = typeof p.file_path === "string" ? p.file_path : Array.isArray(edits) && edits[0]?.file_path ? edits[0].file_path : "";
+      const file = filepath ? filepath.split("/").pop() : "file";
+      return count === 1 ? `Editing: ${file}` : `Editing ${count} changes`;
+    }
+    case "file_write": {
+      const filepath = typeof p.filepath === "string" ? p.filepath : "";
+      const file = filepath.split("/").pop() || filepath;
+      return file ? `Writing: ${file}` : "Writing file";
+    }
+    case "grep_search": {
+      const query = typeof p.query === "string" ? p.query : "";
+      const truncated = query.length > 30 ? `${query.slice(0, 30)}\u2026` : query;
+      return truncated ? `Searching: "${truncated}"` : "Searching";
+    }
+    case "find_by_name": {
+      const pattern = typeof p.pattern === "string" ? p.pattern : "";
+      return pattern ? `Finding: ${pattern}` : "Finding files";
+    }
+    case "view_file_outline": {
+      const filepath = typeof p.file_path === "string" ? p.file_path : "";
+      const file = filepath.split("/").pop() || filepath;
+      return file ? `Outline: ${file}` : "Reading outline";
+    }
+    case "web_fetch": {
+      const url = typeof p.url === "string" ? p.url : "";
+      const truncated = url.length > 40 ? `${url.slice(0, 40)}\u2026` : url;
+      return truncated ? `Fetching: ${truncated}` : "Fetching URL";
+    }
+    case "search_web": {
+      const query = typeof p.query === "string" ? p.query : "";
+      const truncated = query.length > 30 ? `${query.slice(0, 30)}\u2026` : query;
+      return truncated ? `Web search: "${truncated}"` : "Searching web";
+    }
+    case "spawn_agent": {
+      const title = typeof p.title === "string" ? p.title : "";
+      const task = typeof p.task === "string" ? p.task : "";
+      const label = title || (task ? task.slice(0, 40) : "task");
+      return `Spawning agent: ${label}`;
+    }
+    case "wait_agent":
+      return "Waiting for agent";
+    case "list_agents":
+      return "Listing agents";
+    case "todo": {
+      const action = typeof p.action === "string" ? p.action : "update";
+      return `Updating todo: ${action}`;
+    }
+    case "task_boundary": {
+      const mode = typeof p.mode === "string" ? p.mode : "";
+      const taskName = typeof p.task_name === "string" ? p.task_name : "";
+      return taskName ? `${mode}: ${taskName}` : `Task ${mode}`;
+    }
+    case "task_create":
+    case "task_list":
+    case "task_get":
+    case "task_update":
+    case "task_stop": {
+      const title = typeof p.title === "string" ? p.title : "";
+      return title ? `Task: ${title}` : "Managing task";
+    }
+    case "load_skill": {
+      const skill = typeof p.skill_name === "string" ? p.skill_name : "";
+      return skill ? `Loading skill: ${skill}` : "Loading skill";
+    }
+    case "coding_memory": {
+      const action = typeof p.action === "string" ? p.action : "update";
+      return `Coding memory: ${action}`;
+    }
+    case "create_artifact": {
+      const filename = typeof p.filename === "string" ? p.filename : "";
+      return filename ? `Creating: ${filename}` : "Creating artifact";
+    }
+    case "read_artifact": {
+      const filename = typeof p.filename === "string" ? p.filename : "";
+      return filename ? `Reading: ${filename}` : "Reading artifact";
+    }
+    case "message":
+      return "Writing message";
+    case "ask_user_question":
+      return "Asking question";
+    case "enter_plan_mode":
+      return "Entering plan mode";
+    case "exit_plan_mode":
+      return "Exiting plan mode";
+    case "list_mcp_resources":
+      return "Listing MCP resources";
+    case "read_mcp_resource": {
+      const server = typeof p.server === "string" ? p.server : "";
+      const uri = typeof p.uri === "string" ? p.uri : "";
+      return `Reading MCP: ${server || uri || "resource"}`;
+    }
+    case "cron_create":
+      return "Scheduling reminder";
+    case "cron_list":
+      return "Listing reminders";
+    case "cron_delete":
+      return "Canceling reminder";
+    case "notebook_edit": {
+      const filepath = typeof p.filepath === "string" ? p.filepath : "";
+      const file = filepath.split("/").pop() || filepath;
+      return file ? `Editing notebook: ${file}` : "Editing notebook";
+    }
+    case "lsp_query": {
+      const operation = typeof p.operation === "string" ? p.operation : "";
+      return `LSP: ${operation || "query"}`;
+    }
+    default: {
+      const pretty = toolName.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+      return pretty || "Working";
+    }
+  }
+}
+
 // src/app/ui/WorkingTimer.tsx
 import { Fragment as Fragment3, jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -11837,11 +13264,20 @@ function shimmerWorkingLine(text, phase) {
   }).join("");
 }
 var SHIMMER_RAMP_LEN = BLUMA_TERMINAL.workingShimmerRamp.length;
-var WorkingTimerComponent = ({ eventBus, taskName, taskStatus, startedAtMs }) => {
-  const [currentAction, setCurrentAction] = useState4("Thinking");
+var WorkingTimerComponent = ({
+  eventBus,
+  taskName,
+  taskStatus,
+  liveToolName,
+  liveToolArgs,
+  isReasoning,
+  startedAtMs
+}) => {
+  const [currentAction, setCurrentAction] = useState4("working");
   const [frame, setFrame] = useState4(0);
   const [shimmerPhase, setShimmerPhase] = useState4(0);
   const [nowTick, setNowTick] = useState4(() => Date.now());
+  const dynamicActionLabel = liveToolName ? getToolActionLabel(liveToolName, liveToolArgs) : null;
   useEffect4(() => {
     if (!eventBus) return;
     const handleActionStatus = (data) => {
@@ -11874,7 +13310,7 @@ var WorkingTimerComponent = ({ eventBus, taskName, taskStatus, startedAtMs }) =>
     const id = setInterval(() => setNowTick(Date.now()), 500);
     return () => clearInterval(id);
   }, [startedAtMs]);
-  const displayAction = (taskStatus || currentAction).trim() || "Thinking";
+  const displayAction = dynamicActionLabel || (taskStatus || (isReasoning ? "thinking" : currentAction)).trim() || "working";
   const actionLine = `${displayAction}\u2026`;
   const shimmerLine = shimmerWorkingLine(actionLine, shimmerPhase);
   const elapsedMs = startedAtMs != null ? Math.max(0, nowTick - startedAtMs) : 0;
@@ -12127,12 +13563,12 @@ function renderBlockTokens(tokens, keyRoot) {
             /* @__PURE__ */ jsx10(Box10, { flexDirection: "row", flexWrap: "wrap", 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.inactive }) : [/* @__PURE__ */ jsx10(Text10, { bold: true, color: BLUMA_TERMINAL.inactive, wrap: "wrap", children: cell.text }, `${key}-h${idx}-t`)];
-              return /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, flexDirection: "row", flexWrap: "wrap", maxWidth: "100%", children: styled }, idx);
+              return /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, flexDirection: "row", flexWrap: "wrap", children: styled }, idx);
             }) }),
             table.rows.map((row, rowIdx) => /* @__PURE__ */ jsx10(Box10, { flexDirection: "row", flexWrap: "wrap", 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__ */ jsx10(Text10, { dimColor: true, wrap: "wrap", children: cell.text }, `${key}-c${rowIdx}-${cellIdx}-t`)];
-              return /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, flexDirection: "row", flexWrap: "wrap", maxWidth: "100%", children: styled }, cellIdx);
+              return /* @__PURE__ */ jsx10(Box10, { paddingRight: 2, flexDirection: "row", flexWrap: "wrap", children: styled }, cellIdx);
             }) }, `${key}-r${rowIdx}`))
           ] }, key)
         );
@@ -12728,7 +14164,7 @@ var ToolCallDisplayComponent = ({
   const Renderer = getToolRenderer(toolName);
   const shellLike = isShellLikeToolName(toolName);
   return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginBottom: 0, children: [
-    /* @__PURE__ */ jsxs13(Box13, { flexDirection: "row", flexWrap: "wrap", alignItems: "baseline", children: [
+    /* @__PURE__ */ jsxs13(Box13, { flexDirection: "row", flexWrap: "wrap", alignItems: "flex-end", children: [
       /* @__PURE__ */ jsx13(Text13, { color: shellLike ? BLUMA_TERMINAL.m3OnSurface : BLUMA_TERMINAL.inactive, children: TOOL_INVOCATION_MARK }),
       /* @__PURE__ */ jsx13(Text13, { bold: true, color: shellLike ? BLUMA_TERMINAL.m3OnSurface : BLUMA_TERMINAL.claude, children: getToolInvocationTitle(toolName, args) })
     ] }),
@@ -12851,11 +14287,13 @@ function formatLogLine(line) {
 }
 
 // src/app/ui/components/SlashCommands.tsx
+init_session_registry();
 init_sandbox_policy();
 
 // src/app/agent/runtime/diagnostics.ts
 init_runtime_config();
 init_sandbox_policy();
+init_session_registry();
 function buildDiagnosticsSnapshot(feedbackScore) {
   const runtime = getRuntimeConfig();
   const policy = getSandboxPolicy();
@@ -14192,16 +15630,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import path31 from "path";
-import fs26 from "fs";
+import path33 from "path";
+import fs28 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 = path31.join(dir, "package.json");
-    if (fs26.existsSync(candidate)) {
+    const candidate = path33.join(dir, "package.json");
+    if (fs28.existsSync(candidate)) {
       try {
-        const raw = fs26.readFileSync(candidate, "utf8");
+        const raw = fs28.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -14209,7 +15647,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path31.dirname(dir);
+    const parent = path33.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -14218,13 +15656,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path31.resolve(dir);
+    const abs = path33.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path31.dirname(fileURLToPath5(import.meta.url)));
+    const fromBundle = tryFrom(path33.dirname(fileURLToPath5(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -14232,12 +15670,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path31.isAbsolute(argv1) && fs26.existsSync(argv1)) {
-        resolved = fs26.realpathSync(argv1);
+      if (path33.isAbsolute(argv1) && fs28.existsSync(argv1)) {
+        resolved = fs28.realpathSync(argv1);
       } else {
-        resolved = path31.resolve(process.cwd(), argv1);
+        resolved = path33.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path31.dirname(resolved));
+      const fromArgv = tryFrom(path33.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -14610,8 +16048,240 @@ var AskUserQuestionPromptComponent = ({
 };
 var AskUserQuestionPrompt = memo14(AskUserQuestionPromptComponent);
 
-// src/app/ui/App.tsx
+// src/app/ui/components/WorkerOverlay.tsx
+import { useState as useState10 } from "react";
+import { Box as Box25, useInput as useInput5 } from "ink";
+
+// src/app/ui/components/WorkerStatusList.tsx
+import { useEffect as useEffect8, useState as useState8 } from "react";
+import { Box as Box23, Text as Text22 } from "ink";
+import Spinner2 from "ink-spinner";
 import { jsx as jsx24, jsxs as jsxs22 } from "react/jsx-runtime";
+var WorkerStatusList = ({
+  parentSessionId,
+  collapsed = false
+}) => {
+  const [workers, setWorkers] = useState8([]);
+  const [pollKey, setPollKey] = useState8(0);
+  useEffect8(() => {
+    const pollWorkers = async () => {
+      try {
+        const { listAgents: listAgents2 } = await Promise.resolve().then(() => (init_agent_coordination(), agent_coordination_exports));
+        const { listMailboxMessages: listMailboxMessages2 } = await Promise.resolve().then(() => (init_list_mailbox_messages(), list_mailbox_messages_exports));
+        const agentsResult = await listAgents2({ parent_session_id: parentSessionId });
+        if (!agentsResult.success || !agentsResult.agents) {
+          setWorkers([]);
+          return;
+        }
+        const workersInfo = [];
+        const agents = Array.isArray(agentsResult.agents) ? agentsResult.agents : [];
+        for (const agent of agents) {
+          const messagesResult = await listMailboxMessages2({
+            from: agent.session_id,
+            type: "progress_update",
+            unreadOnly: false
+          });
+          let progress = void 0;
+          if (messagesResult.messages && messagesResult.messages.length > 0) {
+            const lastMsg = messagesResult.messages[0];
+            if (lastMsg.metadata?.progress) {
+              progress = {
+                percent: lastMsg.metadata.progress.percent,
+                currentTask: lastMsg.metadata.progress.currentTask,
+                toolCallsCount: lastMsg.metadata.progress.toolCallsCount,
+                tokensUsed: lastMsg.metadata.progress.tokensUsed
+              };
+            }
+          }
+          workersInfo.push({
+            session_id: agent.session_id,
+            title: agent.title || "worker",
+            status: agent.status,
+            started_at: agent.started_at,
+            pid: agent.pid,
+            metadata: agent.metadata,
+            progress,
+            isAlive: agent.status === "running"
+          });
+        }
+        setWorkers(workersInfo);
+      } catch (error) {
+      }
+    };
+    pollWorkers();
+    const interval = setInterval(() => setPollKey((k) => k + 1), 2e3);
+    return () => clearInterval(interval);
+  }, [pollKey, parentSessionId]);
+  if (workers.length === 0) return null;
+  if (collapsed) {
+    return /* @__PURE__ */ jsx24(Box23, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", children: /* @__PURE__ */ jsxs22(Text22, { bold: true, color: "yellow", children: [
+      "Workers: ",
+      workers.length
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs22(Box23, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", children: [
+    /* @__PURE__ */ jsxs22(Text22, { bold: true, color: "yellow", children: [
+      "Workers (",
+      workers.length,
+      ")"
+    ] }),
+    workers.map((w, idx) => /* @__PURE__ */ jsxs22(Box23, { flexDirection: "column", borderBottom: true, borderBottomColor: "gray", children: [
+      /* @__PURE__ */ jsxs22(Box23, { children: [
+        /* @__PURE__ */ jsx24(Text22, { color: "cyan", children: w.metadata?.agent_type === "researcher" ? "[R]" : w.metadata?.agent_type === "implementer" ? "[I]" : "[W]" }),
+        /* @__PURE__ */ jsxs22(Text22, { bold: true, color: "cyan", children: [
+          " ",
+          w.title
+        ] }),
+        w.isAlive === true ? /* @__PURE__ */ jsxs22(Text22, { color: "green", children: [
+          /* @__PURE__ */ jsx24(Spinner2, {}),
+          " Running"
+        ] }) : /* @__PURE__ */ jsx24(Text22, { color: "gray", children: w.status })
+      ] }),
+      w.progress && /* @__PURE__ */ jsxs22(Box23, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs22(Text22, { color: "magenta", children: [
+          "Progress: ",
+          w.progress.percent,
+          "% ",
+          w.progress.currentTask ? `- ${w.progress.currentTask}` : ""
+        ] }),
+        /* @__PURE__ */ jsx24(Box23, { children: /* @__PURE__ */ jsx24(Text22, { color: "gray", children: Array.from({ length: 20 }).map((_, i) => i / 20 * 100 <= (w.progress.percent || 0) ? "#" : "-").join("") }) }),
+        /* @__PURE__ */ jsxs22(Box23, { children: [
+          w.progress.toolCallsCount !== void 0 && /* @__PURE__ */ jsxs22(Text22, { color: "blue", children: [
+            " Tools: ",
+            w.progress.toolCallsCount
+          ] }),
+          w.progress.tokensUsed !== void 0 && /* @__PURE__ */ jsxs22(Text22, { color: "blue", children: [
+            " Tokens: ",
+            w.progress.tokensUsed.toLocaleString()
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs22(Text22, { dimColor: true, color: "gray", children: [
+        "ID: ",
+        w.session_id.slice(0, 8),
+        "... PID: ",
+        w.pid || "N/A",
+        " Started: ",
+        new Date(w.started_at).toLocaleTimeString()
+      ] }),
+      /* @__PURE__ */ jsxs22(Text22, { italic: true, dimColor: true, color: "gray", children: [
+        "Ctrl+Shift+",
+        idx + 1,
+        " para transcript"
+      ] })
+    ] }, w.session_id))
+  ] });
+};
+
+// src/app/ui/components/WorkerTranscript.tsx
+import { useEffect as useEffect9, useState as useState9 } from "react";
+import { Box as Box24, Text as Text23 } from "ink";
+import { jsx as jsx25, jsxs as jsxs23 } from "react/jsx-runtime";
+var WorkerTranscript = ({ sessionId, title, onClose }) => {
+  const [messages, setMessages] = useState9([]);
+  useEffect9(() => {
+    const loadTranscript = async () => {
+      try {
+        const { listMailboxMessages: listMailboxMessages2 } = await Promise.resolve().then(() => (init_list_mailbox_messages(), list_mailbox_messages_exports));
+        const result = await listMailboxMessages2({ from: sessionId, unreadOnly: false, includeSignals: true });
+        if (result.success && result.messages) {
+          setMessages(result.messages);
+        }
+      } catch (error) {
+      }
+    };
+    loadTranscript();
+    const interval = setInterval(loadTranscript, 3e3);
+    return () => clearInterval(interval);
+  }, [sessionId]);
+  return /* @__PURE__ */ jsxs23(Box24, { flexDirection: "column", borderStyle: "double", borderColor: "cyan", children: [
+    /* @__PURE__ */ jsxs23(Box24, { children: [
+      /* @__PURE__ */ jsxs23(Text23, { bold: true, color: "cyan", children: [
+        "Transcript: ",
+        title || sessionId.slice(0, 8),
+        "..."
+      ] }),
+      /* @__PURE__ */ jsx25(Text23, { color: "gray", dimColor: true, children: " ESC: fechar" })
+    ] }),
+    /* @__PURE__ */ jsx25(Box24, { flexDirection: "column", height: 20, children: messages.length === 0 ? /* @__PURE__ */ jsx25(Text23, { dimColor: true, color: "gray", italic: true, children: "Nenhuma mensagem..." }) : messages.map((msg) => /* @__PURE__ */ jsxs23(Box24, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs23(Box24, { children: [
+        /* @__PURE__ */ jsxs23(Text23, { dimColor: true, color: "gray", children: [
+          "[",
+          new Date(msg.timestamp).toLocaleTimeString(),
+          "]"
+        ] }),
+        /* @__PURE__ */ jsxs23(Text23, { color: msg.type === "progress_update" ? "green" : msg.type === "permission_request" ? "yellow" : "cyan", bold: true, children: [
+          " ",
+          msg.type
+        ] }),
+        /* @__PURE__ */ jsxs23(Text23, { dimColor: true, color: "gray", children: [
+          " ",
+          msg.from.slice(0, 8),
+          "... \u2192 ",
+          msg.to.slice(0, 8),
+          "..."
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs23(Text23, { children: [
+        " ",
+        msg.content
+      ] }),
+      msg.metadata?.progress && /* @__PURE__ */ jsxs23(Text23, { color: "magenta", children: [
+        " Progress: ",
+        msg.metadata.progress.percent,
+        "% ",
+        msg.metadata.progress.currentTask || ""
+      ] })
+    ] }, msg.id)) }),
+    /* @__PURE__ */ jsx25(Box24, { borderTop: true, borderTopColor: "gray", children: /* @__PURE__ */ jsxs23(Text23, { dimColor: true, color: "gray", children: [
+      "Total: ",
+      messages.length,
+      " messages | Session: ",
+      sessionId.slice(0, 8),
+      "..."
+    ] }) })
+  ] });
+};
+
+// src/app/ui/components/WorkerOverlay.tsx
+import { jsx as jsx26 } from "react/jsx-runtime";
+var WorkerOverlay = ({
+  visible,
+  sessionId,
+  onClose,
+  onZoomWorker
+}) => {
+  const [zoomedWorker, setZoomedWorker] = useState10(null);
+  useInput5((input, key) => {
+    if (!visible) return;
+    if (key.escape) {
+      if (zoomedWorker) {
+        setZoomedWorker(null);
+      } else {
+        onClose();
+      }
+    }
+  });
+  if (!visible) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx26(Box25, { flexDirection: "column", children: zoomedWorker ? /* @__PURE__ */ jsx26(
+    WorkerTranscript,
+    {
+      sessionId: zoomedWorker,
+      onClose: () => setZoomedWorker(null)
+    }
+  ) : /* @__PURE__ */ jsx26(
+    WorkerStatusList,
+    {
+      parentSessionId: sessionId,
+      collapsed: false
+    }
+  ) });
+};
+
+// src/app/ui/App.tsx
+import { jsx as jsx27, jsxs as jsxs24 } from "react/jsx-runtime";
 var HISTORY_EMERGENCY_LIMIT = 3;
 var HISTORY_KEEP_AFTER_CLEANUP = 3;
 var blumaUpdateRegistryCheckStarted = false;
@@ -14641,51 +16311,67 @@ function UserMessageWithOptionalImages({
     const cap = stripped2.trim();
     const capDisp = cap.length > 800 ? `${cap.slice(0, 800)}\u2026` : cap;
     const fallbackDisp = raw.length > 800 ? `${raw.slice(0, 800)}\u2026` : raw;
-    return /* @__PURE__ */ jsx24(ChatUserMessage, { children: pathStrs.length > 0 ? /* @__PURE__ */ jsx24(
+    return /* @__PURE__ */ jsx27(ChatUserMessage, { children: pathStrs.length > 0 ? /* @__PURE__ */ jsx27(
       ChatUserImageBlock,
       {
         imageCount: pathStrs.length,
         caption: cap.length > 0 ? capDisp : null,
         captionDim: true
       }
-    ) : /* @__PURE__ */ jsx24(Text22, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: fallbackDisp }) });
+    ) : /* @__PURE__ */ jsx27(Text25, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: fallbackDisp }) });
   }
   const displayRaw = raw.length > 1e4 ? `${raw.substring(0, 1e4)}...` : raw;
   const paths = collectImagePathStrings(displayRaw);
   const stripped = paths.length > 0 ? stripImagePathStrings(displayRaw, paths) : displayRaw;
-  return /* @__PURE__ */ jsx24(ChatUserMessage, { children: paths.length > 0 ? /* @__PURE__ */ jsx24(
+  return /* @__PURE__ */ jsx27(ChatUserMessage, { children: paths.length > 0 ? /* @__PURE__ */ jsx27(
     ChatUserImageBlock,
     {
       imageCount: paths.length,
       caption: stripped.trim().length > 0 ? stripped : null
     }
-  ) : /* @__PURE__ */ jsx24(Text22, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: displayRaw }) });
+  ) : /* @__PURE__ */ jsx27(Text25, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: displayRaw }) });
 }
 var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
   const agentInstance = useRef6(null);
-  const [history, setHistory] = useState8([]);
-  const [statusMessage, setStatusMessage] = useState8(
+  const [history, setHistory] = useState11([]);
+  const [statusMessage, setStatusMessage] = useState11(
     "Initializing agent..."
   );
-  const [toolsCount, setToolsCount] = useState8(null);
-  const [mcpStatus, setMcpStatus] = useState8(
+  const [toolsCount, setToolsCount] = useState11(null);
+  const [mcpStatus, setMcpStatus] = useState11(
     "connecting"
   );
-  const [isProcessing, setIsProcessing] = useState8(true);
-  const [pendingConfirmation, setPendingConfirmation] = useState8(
+  const [isProcessing, setIsProcessing] = useState11(true);
+  const [pendingConfirmation, setPendingConfirmation] = useState11(
     null
   );
-  const [confirmationPreview, setConfirmationPreview] = useState8(
+  const [confirmationPreview, setConfirmationPreview] = useState11(
     null
   );
-  const [pendingAskUserQuestions, setPendingAskUserQuestions] = useState8(null);
-  const [isInitAgentActive, setIsInitAgentActive] = useState8(false);
-  const [liveToolName, setLiveToolName] = useState8(null);
+  const [pendingAskUserQuestions, setPendingAskUserQuestions] = useState11(null);
+  const [showWorkers, setShowWorkers] = useState11(false);
+  const [zoomedWorkerSession, setZoomedWorkerSession] = useState11(null);
+  useInput6((input, key) => {
+    if (key.ctrl && key.shift && input.toLowerCase() === "w") {
+      setShowWorkers((prev) => !prev);
+    }
+    if (key.escape && showWorkers) {
+      if (zoomedWorkerSession) {
+        setZoomedWorkerSession(null);
+      } else {
+        setShowWorkers(false);
+      }
+    }
+  });
+  const [isInitAgentActive, setIsInitAgentActive] = useState11(false);
+  const [liveToolName, setLiveToolName] = useState11(null);
+  const [liveToolArgs, setLiveToolArgs] = useState11(void 0);
+  const [isReasoning, setIsReasoning] = useState11(false);
   const alwaysAcceptList = useRef6([]);
   const workdir = process.cwd();
   const turnStartedAtRef = useRef6(null);
-  const [processingStartMs, setProcessingStartMs] = useState8(null);
-  const markTurnStarted = useCallback3(() => {
+  const [processingStartMs, setProcessingStartMs] = useState11(null);
+  const markTurnStarted = useCallback4(() => {
     const t = Date.now();
     turnStartedAtRef.current = t;
     setProcessingStartMs(t);
@@ -14693,7 +16379,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
   const lastReasoningTextRef = useRef6(null);
   const lastStreamAssistantKeyRef = useRef6(null);
   const pendingToolInvocationIdsRef = useRef6(/* @__PURE__ */ new Set());
-  const appendExpandPreviewToHistory = useCallback3(() => {
+  const appendExpandPreviewToHistory = useCallback4(() => {
     const p = peekLatestExpandable();
     setHistory((prev) => {
       const id = prev.length;
@@ -14702,7 +16388,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
           ...prev,
           {
             id,
-            component: /* @__PURE__ */ jsx24(ChatMeta, { children: "Ctrl+O: no truncated preview to expand" }, id)
+            component: /* @__PURE__ */ jsx27(ChatMeta, { children: "Ctrl+O: no truncated preview to expand" }, id)
           }
         ];
       }
@@ -14710,18 +16396,18 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
         ...prev,
         {
           id,
-          component: /* @__PURE__ */ jsx24(ExpandedPreviewBlock, { data: p }, id)
+          component: /* @__PURE__ */ jsx27(ExpandedPreviewBlock, { data: p }, id)
         }
       ];
     });
   }, []);
-  useEffect8(() => {
+  useEffect11(() => {
     expandPreviewHotkeyBus.on("expand", appendExpandPreviewToHistory);
     return () => {
       expandPreviewHotkeyBus.off("expand", appendExpandPreviewToHistory);
     };
   }, [appendExpandPreviewToHistory]);
-  useEffect8(() => {
+  useEffect11(() => {
     if (process.env.CI || blumaUpdateRegistryCheckStarted) return;
     blumaUpdateRegistryCheckStarted = true;
     void checkForUpdates().then((msg) => {
@@ -14732,25 +16418,25 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
           ...prev,
           {
             id: nextId2,
-            component: /* @__PURE__ */ jsx24(UpdateNotice_default, { message: msg })
+            component: /* @__PURE__ */ jsx27(UpdateNotice_default, { message: msg })
           }
         ];
       });
     });
   }, []);
-  useEffect8(() => {
+  useEffect11(() => {
     setHistory((prev) => {
       const tail = prev.filter((h) => h.id !== HEADER_PANEL_HISTORY_ID);
       return [
         {
           id: HEADER_PANEL_HISTORY_ID,
-          component: /* @__PURE__ */ jsx24(Header, { sessionId, workdir, cliVersion })
+          component: /* @__PURE__ */ jsx27(Header, { sessionId, workdir, cliVersion })
         },
         ...tail
       ];
     });
   }, [sessionId, workdir, cliVersion]);
-  const handleInterrupt = useCallback3(() => {
+  const handleInterrupt = useCallback4(() => {
     if (!isProcessing) return;
     eventBus.emit("user_interrupt");
     turnStartedAtRef.current = null;
@@ -14762,12 +16448,12 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
         ...prev,
         {
           id,
-          component: /* @__PURE__ */ jsx24(ChatMeta, { children: "cancelled (Esc)" })
+          component: /* @__PURE__ */ jsx27(ChatMeta, { children: "cancelled (Esc)" })
         }
       ];
     });
   }, [isProcessing, eventBus]);
-  const handleSubmit = useCallback3(
+  const handleSubmit = useCallback4(
     (text) => {
       if (!text || !agentInstance.current) return;
       const trimmedForSlash = text.trim();
@@ -14779,7 +16465,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
               ...prev,
               {
                 id,
-                component: /* @__PURE__ */ jsx24(ChatMeta, { children: "Slash command not recognized or incomplete. Type /help for the list." })
+                component: /* @__PURE__ */ jsx27(ChatMeta, { children: "Slash command not recognized or incomplete. Type /help for the list." })
               }
             ];
           });
@@ -14797,7 +16483,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
               ...prev,
               {
                 id,
-                component: /* @__PURE__ */ jsx24(ChatMeta, { children: "Usage: /img ./screenshot.png \u2014 optional text after the path is sent too" })
+                component: /* @__PURE__ */ jsx27(ChatMeta, { children: "Usage: /img ./screenshot.png \u2014 optional text after the path is sent too" })
               }
             ];
           });
@@ -14816,7 +16502,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
             ...prev,
             {
               id,
-              component: /* @__PURE__ */ jsx24(UserMessageWithOptionalImages, { raw: payload, variant: "slash-img" })
+              component: /* @__PURE__ */ jsx27(UserMessageWithOptionalImages, { raw: payload, variant: "slash-img" })
             }
           ];
         });
@@ -14849,11 +16535,11 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
             ...prev,
             {
               id: firstId,
-              component: /* @__PURE__ */ jsx24(ChatUserMessage, { children: /* @__PURE__ */ jsx24(Text22, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: text }) })
+              component: /* @__PURE__ */ jsx27(ChatUserMessage, { children: /* @__PURE__ */ jsx27(Text25, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: text }) })
             },
             {
               id: secondId,
-              component: /* @__PURE__ */ jsx24(
+              component: /* @__PURE__ */ jsx27(
                 SlashCommands_default,
                 {
                   input: text,
@@ -14885,7 +16571,7 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
             ...prev,
             {
               id,
-              component: /* @__PURE__ */ jsx24(ChatUserMessage, { children: /* @__PURE__ */ jsxs22(Text22, { bold: true, color: "white", children: [
+              component: /* @__PURE__ */ jsx27(ChatUserMessage, { children: /* @__PURE__ */ jsxs24(Text25, { bold: true, color: "white", children: [
                 "$ !",
                 command
               ] }) })
@@ -14911,7 +16597,7 @@ Please use command_status to check the result and report back to the user.`;
                   ...prev,
                   {
                     id,
-                    component: /* @__PURE__ */ jsxs22(Text22, { color: "red", children: [
+                    component: /* @__PURE__ */ jsxs24(Text25, { color: "red", children: [
                       "Failed to execute: ",
                       result.error || result.message
                     ] })
@@ -14929,7 +16615,7 @@ Please use command_status to check the result and report back to the user.`;
                 ...prev,
                 {
                   id,
-                  component: /* @__PURE__ */ jsxs22(Text22, { color: "red", children: [
+                  component: /* @__PURE__ */ jsxs24(Text25, { color: "red", children: [
                     "Error: ",
                     err.message
                   ] })
@@ -14949,7 +16635,7 @@ Please use command_status to check the result and report back to the user.`;
           ...prev,
           {
             id,
-            component: /* @__PURE__ */ jsx24(UserMessageWithOptionalImages, { raw: text, variant: "plain" })
+            component: /* @__PURE__ */ jsx27(UserMessageWithOptionalImages, { raw: text, variant: "plain" })
           }
         ];
       });
@@ -14957,7 +16643,7 @@ Please use command_status to check the result and report back to the user.`;
     },
     [isProcessing, markTurnStarted]
   );
-  const handleConfirmation = useCallback3(
+  const handleConfirmation = useCallback4(
     (decision, toolCalls, opts) => {
       if (!agentInstance.current) return;
       setPendingConfirmation(null);
@@ -14979,7 +16665,7 @@ Please use command_status to check the result and report back to the user.`;
     },
     []
   );
-  const appendStreamedReasoning = useCallback3((reasoning) => {
+  const appendStreamedReasoning = useCallback4((reasoning) => {
     const r = String(reasoning ?? "").trim();
     const key = reasoningDedupeKey(r);
     if (!r || key === lastReasoningTextRef.current) return;
@@ -14990,12 +16676,12 @@ Please use command_status to check the result and report back to the user.`;
         ...prev,
         {
           id,
-          component: /* @__PURE__ */ jsx24(ReasoningDisplay, { reasoning })
+          component: /* @__PURE__ */ jsx27(ReasoningDisplay, { reasoning })
         }
       ];
     });
   }, []);
-  const appendStreamedAssistant = useCallback3((content) => {
+  const appendStreamedAssistant = useCallback4((content) => {
     const t = String(content ?? "").trim();
     if (!t) return;
     const key = reasoningDedupeKey(t);
@@ -15006,12 +16692,12 @@ Please use command_status to check the result and report back to the user.`;
         ...prev,
         {
           id,
-          component: /* @__PURE__ */ jsx24(AssistantMessageDisplay, { content })
+          component: /* @__PURE__ */ jsx27(AssistantMessageDisplay, { content })
         }
       ];
     });
   }, []);
-  useEffect8(() => {
+  useEffect11(() => {
     if (history.length >= HISTORY_EMERGENCY_LIMIT) {
       setHistory((prev) => {
         const header = prev.find((h) => h.id === HEADER_PANEL_HISTORY_ID);
@@ -15021,7 +16707,7 @@ Please use command_status to check the result and report back to the user.`;
       });
     }
   }, [history.length]);
-  useEffect8(() => {
+  useEffect11(() => {
     const initializeAgent = async () => {
       try {
         agentInstance.current = new Agent(sessionId, eventBus);
@@ -15058,7 +16744,7 @@ Please use command_status to check the result and report back to the user.`;
               ...prev,
               {
                 id,
-                component: /* @__PURE__ */ jsx24(ChatTurnDuration, { durationMs: ms })
+                component: /* @__PURE__ */ jsx27(ChatTurnDuration, { durationMs: ms })
               }
             ];
           });
@@ -15080,6 +16766,31 @@ Please use command_status to check the result and report back to the user.`;
           });
           return;
         }
+        if (parsed.type === "tool_stream_start") {
+          const toolName = String(parsed.toolName || "");
+          const argsRaw = parsed.argsRaw;
+          let args = void 0;
+          if (typeof argsRaw === "string") {
+            try {
+              args = JSON.parse(argsRaw);
+            } catch {
+              args = argsRaw;
+            }
+          } else {
+            args = argsRaw;
+          }
+          if (toolName) {
+            setLiveToolName(toolName);
+            setLiveToolArgs(args);
+          }
+          return;
+        }
+        if (parsed.type === "reasoning") {
+          setIsReasoning(true);
+        }
+        if (parsed.type === "stream_end") {
+          setIsReasoning(false);
+        }
         if (parsed.type === "ask_user_question") {
           const qs = parsed.questions;
           if (Array.isArray(qs) && qs.length > 0) {
@@ -15143,14 +16854,14 @@ Please use command_status to check the result and report back to the user.`;
         }
         let newComponent = null;
         if (parsed.type === "debug") {
-          newComponent = /* @__PURE__ */ jsx24(ChatMeta, { children: parsed.message });
+          newComponent = /* @__PURE__ */ jsx27(ChatMeta, { children: parsed.message });
         } else if (parsed.type === "protocol_violation") {
-          newComponent = /* @__PURE__ */ jsx24(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs22(Box23, { flexDirection: "column", paddingLeft: 2, children: [
-            /* @__PURE__ */ jsx24(Text22, { dimColor: true, children: parsed.content }),
-            /* @__PURE__ */ jsx24(Text22, { dimColor: true, children: parsed.message })
+          newComponent = /* @__PURE__ */ jsx27(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsxs24(Box26, { flexDirection: "column", paddingLeft: 2, children: [
+            /* @__PURE__ */ jsx27(Text25, { dimColor: true, children: parsed.content }),
+            /* @__PURE__ */ jsx27(Text25, { dimColor: true, children: parsed.message })
           ] }) });
         } else if (parsed.type === "error") {
-          newComponent = /* @__PURE__ */ jsx24(
+          newComponent = /* @__PURE__ */ jsx27(
             ErrorMessage_default,
             {
               message: parsed.message,
@@ -15168,6 +16879,7 @@ Please use command_status to check the result and report back to the user.`;
           });
           if (parsed.tool_name) {
             setLiveToolName(String(parsed.tool_name));
+            setLiveToolArgs(parsed.arguments);
           }
           const tn = String(parsed.tool_name || "");
           if (isToolInvocationRowVisible(tn)) {
@@ -15176,7 +16888,7 @@ Please use command_status to check the result and report back to the user.`;
               parsed.tool_call_id
             );
           }
-          newComponent = isToolInvocationRowVisible(tn) ? /* @__PURE__ */ jsx24(
+          newComponent = isToolInvocationRowVisible(tn) ? /* @__PURE__ */ jsx27(
             ToolInvocationBlock,
             {
               toolName: tn,
@@ -15197,7 +16909,7 @@ Please use command_status to check the result and report back to the user.`;
             pendingToolInvocationIdsRef.current,
             parsed.tool_call_id
           );
-          newComponent = /* @__PURE__ */ jsx24(
+          newComponent = /* @__PURE__ */ jsx27(
             ToolResultDisplay,
             {
               toolName: parsed.tool_name,
@@ -15208,7 +16920,7 @@ Please use command_status to check the result and report back to the user.`;
             }
           );
         } else if (parsed.type === "user_overlay") {
-          newComponent = /* @__PURE__ */ jsx24(ChatUserMessage, { children: /* @__PURE__ */ jsx24(Text22, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: parsed.payload }) });
+          newComponent = /* @__PURE__ */ jsx27(ChatUserMessage, { children: /* @__PURE__ */ jsx27(Text25, { color: BLUMA_TERMINAL.m3OnSurface, bold: true, wrap: "wrap", children: parsed.payload }) });
         } else if (parsed.type === "reasoning") {
           const r = String(parsed.content ?? "").trim();
           const key = reasoningDedupeKey(r);
@@ -15216,10 +16928,10 @@ Please use command_status to check the result and report back to the user.`;
             newComponent = null;
           } else {
             if (r) lastReasoningTextRef.current = key;
-            newComponent = /* @__PURE__ */ jsx24(ReasoningDisplay, { reasoning: String(parsed.content ?? "") });
+            newComponent = /* @__PURE__ */ jsx27(ReasoningDisplay, { reasoning: String(parsed.content ?? "") });
           }
         } else if (parsed.type === "log") {
-          newComponent = /* @__PURE__ */ jsxs22(ChatMeta, { children: [
+          newComponent = /* @__PURE__ */ jsxs24(ChatMeta, { children: [
             parsed.message,
             parsed.payload ? `: ${parsed.payload}` : ""
           ] });
@@ -15230,7 +16942,7 @@ Please use command_status to check the result and report back to the user.`;
             newComponent = null;
           } else {
             lastStreamAssistantKeyRef.current = key || null;
-            newComponent = /* @__PURE__ */ jsx24(AssistantMessageDisplay, { content: body });
+            newComponent = /* @__PURE__ */ jsx27(AssistantMessageDisplay, { content: body });
           }
         }
         if (newComponent) {
@@ -15248,7 +16960,7 @@ Please use command_status to check the result and report back to the user.`;
                 const ms = Date.now() - t;
                 next.push({
                   id: nextHistoryId(next),
-                  component: /* @__PURE__ */ jsx24(ChatTurnDuration, { durationMs: ms })
+                  component: /* @__PURE__ */ jsx27(ChatTurnDuration, { durationMs: ms })
                 });
               }
             }
@@ -15266,7 +16978,7 @@ Please use command_status to check the result and report back to the user.`;
       if (!msg) return;
       setHistory((prev) => {
         const id = nextHistoryId(prev);
-        return [...prev, { id, component: /* @__PURE__ */ jsx24(ChatMeta, { children: msg }) }];
+        return [...prev, { id, component: /* @__PURE__ */ jsx27(ChatMeta, { children: msg }) }];
       });
     };
     uiEventBus.on("user_overlay", handleUiOverlay);
@@ -15281,7 +16993,7 @@ Please use command_status to check the result and report back to the user.`;
   }, [eventBus, sessionId, handleConfirmation]);
   const renderInteractiveComponent = () => {
     if (mcpStatus !== "connected") {
-      return /* @__PURE__ */ jsx24(
+      return /* @__PURE__ */ jsx27(
         SessionInfoConnectingMCP_default,
         {
           workdir,
@@ -15289,8 +17001,8 @@ Please use command_status to check the result and report back to the user.`;
         }
       );
     }
-    return /* @__PURE__ */ jsxs22(Box23, { flexDirection: "column", children: [
-      pendingAskUserQuestions && pendingAskUserQuestions.length > 0 ? /* @__PURE__ */ jsx24(
+    return /* @__PURE__ */ jsxs24(Box26, { flexDirection: "column", children: [
+      pendingAskUserQuestions && pendingAskUserQuestions.length > 0 ? /* @__PURE__ */ jsx27(
         AskUserQuestionPrompt,
         {
           questions: pendingAskUserQuestions,
@@ -15306,7 +17018,7 @@ Please use command_status to check the result and report back to the user.`;
           }
         }
       ) : null,
-      pendingConfirmation ? /* @__PURE__ */ jsx24(
+      pendingConfirmation ? /* @__PURE__ */ jsx27(
         ConfirmationPrompt,
         {
           toolCalls: pendingConfirmation,
@@ -15319,8 +17031,17 @@ Please use command_status to check the result and report back to the user.`;
           }
         }
       ) : null,
-      isProcessing && !pendingConfirmation && !pendingAskUserQuestions && /* @__PURE__ */ jsx24(WorkingTimer, { eventBus, startedAtMs: processingStartMs }),
-      /* @__PURE__ */ jsx24(
+      isProcessing && !pendingConfirmation && !pendingAskUserQuestions && /* @__PURE__ */ jsx27(
+        WorkingTimer,
+        {
+          eventBus,
+          startedAtMs: processingStartMs,
+          liveToolName,
+          liveToolArgs,
+          isReasoning
+        }
+      ),
+      /* @__PURE__ */ jsx27(
         InputPrompt,
         {
           onSubmit: handleSubmit,
@@ -15332,10 +17053,10 @@ Please use command_status to check the result and report back to the user.`;
       )
     ] });
   };
-  return /* @__PURE__ */ jsxs22(Box23, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx24(Static, { items: history, children: (item) => /* @__PURE__ */ jsx24(Box23, { children: item.component }, item.id) }),
-    liveToolName ? /* @__PURE__ */ jsx24(Box23, { paddingLeft: 2, marginBottom: 0, children: /* @__PURE__ */ jsxs22(Text22, { dimColor: true, children: [
-      /* @__PURE__ */ jsxs22(Text22, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: [
+  return /* @__PURE__ */ jsxs24(Box26, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx27(Static, { items: history, children: (item) => /* @__PURE__ */ jsx27(Box26, { children: item.component }, item.id) }),
+    liveToolName ? /* @__PURE__ */ jsx27(Box26, { paddingLeft: 2, marginBottom: 0, children: /* @__PURE__ */ jsxs24(Text25, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs24(Text25, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: [
         "*",
         " "
       ] }),
@@ -15343,7 +17064,7 @@ Please use command_status to check the result and report back to the user.`;
       liveToolName,
       "\u2026"
     ] }) }) : null,
-    /* @__PURE__ */ jsx24(
+    /* @__PURE__ */ jsx27(
       StreamingText,
       {
         eventBus,
@@ -15351,7 +17072,19 @@ Please use command_status to check the result and report back to the user.`;
         onAssistantContentComplete: appendStreamedAssistant
       }
     ),
-    renderInteractiveComponent()
+    renderInteractiveComponent(),
+    showWorkers && /* @__PURE__ */ jsx27(
+      WorkerOverlay,
+      {
+        visible: showWorkers,
+        sessionId,
+        onClose: () => {
+          setShowWorkers(false);
+          setZoomedWorkerSession(null);
+        },
+        onZoomWorker: setZoomedWorkerSession
+      }
+    )
   ] });
 };
 var App = memo15(AppComponent);
@@ -15413,6 +17146,7 @@ function stopTitleKeeper() {
 }
 
 // src/main.ts
+init_session_registry();
 function extractUserMessage(envelope) {
   const c = envelope.context;
   if (c && typeof c === "object" && typeof c.user_request === "string") {
@@ -15477,9 +17211,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs27.readFileSync(filePath, "utf-8");
+      rawPayload = fs29.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs27.readFileSync(0, "utf-8");
+      rawPayload = fs29.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -15517,7 +17251,7 @@ async function runAgentMode() {
     }
   }
   const eventBus = new EventEmitter3();
-  const sessionId = registrySessionId || envelope.session_id || envelope.message_id || uuidv47();
+  const sessionId = registrySessionId || envelope.session_id || envelope.message_id || uuidv48();
   process.env.BLUMA_SESSION_ID = sessionId;
   installSessionLifecycle(sessionId);
   const uc = envelope.user_context;
@@ -15628,7 +17362,9 @@ async function runAgentMode() {
     const agent = new Agent(sessionId, eventBus);
     agentRef = agent;
     await agent.initialize();
-    const userContent = JSON.stringify({
+    const userRequest = envelope.context?.user_request || envelope.context?.userRequest || "";
+    const coordinatorContext = envelope.context?.coordinator_context || envelope.context?.coordinatorContext || "";
+    const userContent = userRequest ? `${userRequest}${coordinatorContext ? "\n\nContexto adicional:\n" + JSON.stringify(coordinatorContext, null, 2) : ""}` : JSON.stringify({
       message_id: envelope.message_id || sessionId,
       from_agent: envelope.from_agent || "unknown",
       to_agent: envelope.to_agent || "bluma",
@@ -15675,9 +17411,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path32.dirname(fileURLToPath6(import.meta.url));
-    const pkgPath = path32.join(base, "..", "package.json");
-    const j = JSON.parse(fs27.readFileSync(pkgPath, "utf8"));
+    const base = path34.dirname(fileURLToPath6(import.meta.url));
+    const pkgPath = path34.join(base, "..", "package.json");
+    const j = JSON.parse(fs29.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -15687,7 +17423,7 @@ function runCliMode(sessionId) {
   const BLUMA_TITLE = "bluma";
   startTitleKeeper(BLUMA_TITLE);
   const eventBus = new EventEmitter3();
-  const resolvedSessionId = sessionId || uuidv47();
+  const resolvedSessionId = sessionId || uuidv48();
   process.env.BLUMA_SESSION_ID = resolvedSessionId;
   registerSession({
     sessionId: resolvedSessionId,
@@ -15705,7 +17441,7 @@ function runCliMode(sessionId) {
     sessionId: resolvedSessionId,
     cliVersion: readCliPackageVersion()
   };
-  const instance = render(React16.createElement(App_default, props));
+  const instance = render(React19.createElement(App_default, props));
   void instance.waitUntilExit().then(() => {
     finalizeSession(resolvedSessionId, "completed", { finishedBy: "interactive-exit" });
   });
@@ -15800,9 +17536,9 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs27.readFileSync(filePath, "utf-8");
+  const rawPayload = fs29.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
-  const sessionId = envelope.session_id || envelope.message_id || uuidv47();
+  const sessionId = envelope.session_id || envelope.message_id || uuidv48();
   registerSession({
     sessionId,
     kind: "agent",