@nomad-e/bluma-cli 0.1.51 → 0.1.52

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 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);
+}
+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 os10 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(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"
+  };
+}
+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 os11 from "os";
+import path19 from "path";
+import { v4 as uuidv44 } from "uuid";
+function getMailboxesDir() {
+  if (mailboxesDir) {
+    return mailboxesDir;
+  }
+  mailboxesDir = path19.join(process.env.HOME || os11.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 fs28 from "fs";
+import path33 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 path34 = 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: path34 })
     ] }) }),
     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 path34 = 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
+      path34
     ] })
   ] });
 };
@@ -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 path31 from "path";
+import os20 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
@@ -6901,261 +7583,162 @@ async function webFetch(args) {
   }
 }
 
-// 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);
+// 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 {
-      conversationId: parsed.conversationId ?? null,
-      userId: parsed.userId ?? null,
-      userName: parsed.userName ?? null,
-      userEmail: parsed.userEmail ?? null,
-      companyId: parsed.companyId ?? null,
-      companyName: parsed.companyName ?? null
+      success: false,
+      message_id: "",
+      worker_session_id: to,
+      status: "error",
+      error: "to (worker session ID) is required"
     };
-  } 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 {
-    }
+  if (!message2 || typeof message2 !== "string") {
+    return {
+      success: false,
+      message_id: "",
+      worker_session_id: to,
+      status: "error",
+      error: "message is required"
+    };
   }
-  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 workerSession = getSession(to);
+  if (!workerSession) {
+    return {
+      success: false,
+      message_id: "",
+      worker_session_id: to,
+      status: "error",
+      error: `Worker session ${to} not found`
+    };
   }
-  const entrypoint = process.argv[1];
-  if (!entrypoint) {
-    return { success: false, error: "Unable to resolve CLI entrypoint for worker spawn" };
+  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 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 || ""
-      }
+  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: false,
+        message_id: messageId,
+        worker_session_id: to,
+        status: ackResult.timedOut ? "timeout" : "error",
+        error: ackResult.error,
+        ack_received: false,
+        worker_status: workerSession.status
+      };
     }
-  );
-  child.unref();
-  updateSession(sessionId, { pid: child.pid });
+  }
   return {
     success: true,
-    session_id: sessionId,
-    pid: child.pid || null,
-    parent_session_id: parentSessionId,
-    title,
-    status: "running"
+    message_id: messageId,
+    worker_session_id: to,
+    status: waitForAck ? "delivered" : "sent",
+    ack_received: waitForAck,
+    worker_status: workerSession.status
   };
 }
-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));
+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 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)
-      };
+    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"
+          };
+        }
+      }
     }
-    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+    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
+    };
   }
-  const session = getSession(sessionId);
-  if (!session) {
-    return { success: false, error: `Unknown session: ${sessionId}` };
+  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,
-    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
+    signal_id: signalId,
+    type,
+    to
   };
 }
 
@@ -7589,6 +8172,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 +8256,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,9 +8300,9 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs18 } from "fs";
-import path20 from "path";
-import os11 from "os";
+import { promises as fs19 } from "fs";
+import path21 from "path";
+import os12 from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -7702,9 +8329,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(os12.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -7738,7 +8365,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) {
@@ -7757,7 +8384,7 @@ var MCPClient = class {
   async connectToStdioServer(serverName, config2) {
     let commandToExecute = config2.command;
     let argsToExecute = config2.args || [];
-    const isWindows = os11.platform() === "win32";
+    const isWindows = os12.platform() === "win32";
     if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
       if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
         commandToExecute = argsToExecute[1];
@@ -7909,13 +8536,13 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path28 from "path";
-import { v4 as uuidv44 } from "uuid";
+import path29 from "path";
+import { v4 as uuidv45 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path21 from "path";
-import os12 from "os";
-import { promises as fs19 } from "fs";
+import path22 from "path";
+import os13 from "os";
+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 +8578,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(os13.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path21.join(os12.homedir(), ".bluma");
-  return path21.resolve(expandHome(fixed));
+  const fixed = path22.join(os13.homedir(), ".bluma");
+  return path22.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -7965,10 +8592,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 +8608,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 +8627,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 +8649,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 +8661,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 +8677,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 +8700,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 +8709,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,15 +8726,15 @@ 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 fs24 from "fs";
+import path26 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 os13 from "os";
+import fs21 from "fs";
+import path23 from "path";
+import os14 from "os";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var SkillLoader = class _SkillLoader {
   bundledSkillsDir;
@@ -8116,8 +8743,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(os14.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -8126,48 +8753,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(os14.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -8196,8 +8823,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 +8832,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 +8867,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 +8911,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 +8922,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 +8994,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 +9029,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 +9045,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 +9059,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 +9067,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 +9082,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 +9118,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 +9176,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 +9194,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 +9242,15 @@ init_runtime_config();
 
 // src/app/agent/runtime/plugin_registry.ts
 init_sandbox_policy();
-import fs22 from "fs";
-import os14 from "os";
-import path24 from "path";
+import fs23 from "fs";
+import os15 from "os";
+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 || os15.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -8632,11 +9259,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 +9276,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 +9352,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 +9362,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\`:
 
@@ -8940,10 +9570,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 (fs24.existsSync(path26.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs24.existsSync(path26.join(dir, "yarn.lock"))) return "yarn";
+    if (fs24.existsSync(path26.join(dir, "bun.lockb"))) return "bun";
+    if (fs24.existsSync(path26.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -8951,9 +9581,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs23.readdirSync(dir);
+    const files = fs24.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs23.readFileSync(path25.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs24.readFileSync(path26.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 +9602,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 = path26.join(dir, "package.json");
+    if (fs24.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -8983,7 +9613,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 (fs24.existsSync(path26.join(dir, "pytest.ini")) || fs24.existsSync(path26.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -8991,9 +9621,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 = path26.join(dir, "package.json");
+    if (fs24.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -9151,12 +9781,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",
@@ -9214,8 +9844,8 @@ ${memorySnapshot.trim().length > 0 ? memorySnapshot : "(empty \u2014 use coding_
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path25.join(dir, ".git");
-    return fs23.existsSync(gitPath) && fs23.lstatSync(gitPath).isDirectory();
+    const gitPath = path26.join(dir, ".git");
+    return fs24.existsSync(gitPath) && fs24.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -9432,16 +10062,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 +10090,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 +10107,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 +10122,7 @@ function getPreferredMacAddress() {
   } catch {
   }
   try {
-    return `host:${os16.hostname()}`;
+    return `host:${os17.hostname()}`;
   } catch {
     return "unknown";
   }
@@ -9496,7 +10132,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 +10579,8 @@ function classifyToolInvocation(input) {
 
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
-import fs24 from "fs";
-import path26 from "path";
+import fs25 from "fs";
+import path27 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -9955,7 +10591,7 @@ var cache2 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path26.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path27.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -9974,8 +10610,8 @@ function ensureLoaded2() {
     return cache2;
   }
   try {
-    if (fs24.existsSync(statePath)) {
-      const parsed = JSON.parse(fs24.readFileSync(statePath, "utf-8"));
+    if (fs25.existsSync(statePath)) {
+      const parsed = JSON.parse(fs25.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 +10637,9 @@ function ensureLoaded2() {
 }
 function persist2(state) {
   const statePath = getStatePath();
-  fs24.mkdirSync(path26.dirname(statePath), { recursive: true });
+  fs25.mkdirSync(path27.dirname(statePath), { recursive: true });
   state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs24.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
+  fs25.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf-8");
   cache2 = state;
   cachePath2 = statePath;
 }
@@ -10100,11 +10736,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 fs26 from "fs";
+import * as path28 from "path";
+import os18 from "os";
 function memoryPath() {
-  return path27.join(process.env.HOME || os17.homedir(), ".bluma", "coding_memory.json");
+  return path28.join(process.env.HOME || os18.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -10114,18 +10750,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath();
-  if (!fs25.existsSync(p)) {
+  if (!fs26.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs25.copyFileSync(p, bak);
+    fs26.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(fs26.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -10160,7 +10796,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs25.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs26.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -10353,7 +10989,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 +11391,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path28.basename(toolArgs.file_path);
+      const filename = path29.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 +11427,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 +11503,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 +11534,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,6 +11702,37 @@ ${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
@@ -11062,13 +11747,13 @@ function getSubAgentByCommand(cmd) {
 }
 
 // src/app/agent/subagents/init/init_subagent.ts
-import { v4 as uuidv46 } from "uuid";
+import { v4 as uuidv47 } from "uuid";
 
 // src/app/agent/subagents/base_llm_subagent.ts
-import { v4 as uuidv45 } from "uuid";
+import { v4 as uuidv46 } from "uuid";
 
 // src/app/agent/subagents/init/init_system_prompt.ts
-import os18 from "os";
+import os19 from "os";
 var SYSTEM_PROMPT2 = `
 
 ### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -11231,12 +11916,12 @@ Rule Summary:
 function getInitPrompt() {
   const now2 = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os18.type(),
-    os_version: os18.release(),
-    architecture: os18.arch(),
+    os_type: os19.type(),
+    os_version: os19.release(),
+    architecture: os19.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os18.userInfo().username || "Unknown",
+    username: os19.userInfo().username || "Unknown",
     current_date: now2.toISOString().split("T")[0],
     // Formato YYYY-MM-DD
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
@@ -11281,7 +11966,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,
@@ -11449,7 +12134,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 +12228,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path33, handler) {
-    this.routeHandlers.set(path33, handler);
+  registerRoute(path34, handler) {
+    this.routeHandlers.set(path34, 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 [path34, handler] of this.routeHandlers) {
+      if (inputText === path34 || inputText.startsWith(`${path34} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -11559,13 +12244,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path29 from "path";
+import path30 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 = path30.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -11586,7 +12271,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path30.join(os19.homedir(), ".bluma", ".env");
+var globalEnvPath = path31.join(os20.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -11820,6 +12505,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 +12678,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 +12724,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 +12977,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 +13578,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 +13701,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 +15044,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 path32 from "path";
+import fs27 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 = path32.join(dir, "package.json");
+    if (fs27.existsSync(candidate)) {
       try {
-        const raw = fs26.readFileSync(candidate, "utf8");
+        const raw = fs27.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 +15061,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path31.dirname(dir);
+    const parent = path32.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -14218,13 +15070,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path31.resolve(dir);
+    const abs = path32.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(path32.dirname(fileURLToPath5(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -14232,12 +15084,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path31.isAbsolute(argv1) && fs26.existsSync(argv1)) {
-        resolved = fs26.realpathSync(argv1);
+      if (path32.isAbsolute(argv1) && fs27.existsSync(argv1)) {
+        resolved = fs27.realpathSync(argv1);
       } else {
-        resolved = path31.resolve(process.cwd(), argv1);
+        resolved = path32.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path31.dirname(resolved));
+      const fromArgv = tryFrom(path32.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -14610,8 +15462,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 +15725,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 +15793,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 +15802,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 +15810,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 +15832,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 +15862,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 +15879,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 +15897,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 +15916,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 +15949,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 +15985,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 +16011,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 +16029,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 +16049,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 +16057,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 +16079,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 +16090,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 +16106,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 +16121,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 +16158,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 +16180,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 +16268,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 +16293,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 +16302,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 +16323,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 +16334,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 +16342,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 +16356,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 +16374,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 +16392,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 +16407,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 +16415,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 +16432,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 +16445,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 +16467,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 +16478,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 +16486,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 +16560,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 +16625,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs27.readFileSync(filePath, "utf-8");
+      rawPayload = fs28.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs27.readFileSync(0, "utf-8");
+      rawPayload = fs28.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -15517,7 +16665,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;
@@ -15675,9 +16823,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 = path33.dirname(fileURLToPath6(import.meta.url));
+    const pkgPath = path33.join(base, "..", "package.json");
+    const j = JSON.parse(fs28.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -15687,7 +16835,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 +16853,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 +16948,9 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs27.readFileSync(filePath, "utf-8");
+  const rawPayload = fs28.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",