@nomad-e/bluma-cli 0.1.45 → 0.1.46

package/dist/main.js

@@ -884,11 +884,17 @@ var useCustomInput = ({
         return;
       }
       if (key.escape) {
+        if (globalThis.__BLUMA_SLASH_MENU_OPEN__) {
+          return;
+        }
         onInterrupt();
         return;
       }
       if (isReadOnly) {
         if (key.return && !key.shift) {
+          if (globalThis.__BLUMA_SLASH_MENU_OPEN__) {
+            return;
+          }
           if (state.text.trim().length > 0) {
             onSubmit(state.text);
             dispatch({ type: "SUBMIT" });
@@ -899,6 +905,10 @@ var useCustomInput = ({
           dispatch({ type: "NEWLINE" });
           return;
         }
+        if (globalThis.__BLUMA_SLASH_MENU_OPEN__) {
+          if (key.tab) return;
+          if (key.upArrow || key.downArrow) return;
+        }
         if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
         if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
         if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
@@ -924,6 +934,7 @@ var useCustomInput = ({
       }
       if (key.return) {
         if (globalThis.__BLUMA_AT_OPEN__) return;
+        if (globalThis.__BLUMA_SLASH_MENU_OPEN__) return;
         if (globalThis.__BLUMA_SUPPRESS_SUBMIT__) {
           globalThis.__BLUMA_SUPPRESS_SUBMIT__ = false;
           return;
@@ -934,6 +945,10 @@ var useCustomInput = ({
         }
         return;
       }
+      if (globalThis.__BLUMA_SLASH_MENU_OPEN__) {
+        if (key.tab) return;
+        if (key.upArrow || key.downArrow) return;
+      }
       if (key.leftArrow) return dispatch({ type: "MOVE_CURSOR", direction: "left" });
       if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
       if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
@@ -951,6 +966,7 @@ var useCustomInput = ({
         void Promise.resolve(onChordPaste(insertAtCursor));
         return;
       }
+      if (key.tab && globalThis.__BLUMA_SLASH_MENU_OPEN__) return;
       if (key.ctrl || key.meta || key.tab) return;
       inputBuffer.current += input;
       if (!flushScheduled.current) {
@@ -1090,8 +1106,13 @@ var getSlashCommands = () => [
   },
   {
     name: "/agent",
-    description: "coordinator prompt mode: /agent [default|coordinator]",
-    category: "inspect"
+    description: "prompt profile (not /agents): /agent [default|coordinator] \u2014 coordinator playbook in system prompt; then /init",
+    category: "agent"
+  },
+  {
+    name: "/agents",
+    description: "list worker/agent sessions (spawn_agent children in this CLI)",
+    category: "agent"
   },
   {
     name: "/features",
@@ -2208,9 +2229,23 @@ var InputPrompt = memo2(({
     const resolved = resolveInlineImageLabels(valueForAgent, map);
     if (isReadOnly) {
       if (trimmed.length > 0) {
+        const routeText = resolved.trim();
+        if (isSlashRoutingLine(routeText)) {
+          onSubmit(resolved);
+          clearInlineImageSlots();
+          return;
+        }
+        if (routeText.startsWith("/")) {
+          uiEventBus.emit("input_notice", {
+            message: "Unknown or incomplete slash command while the agent runs. Type /help for the list, or finish the command name.",
+            ts: Date.now()
+          });
+          clearInlineImageSlots();
+          return;
+        }
         uiEventBus.emit("user_overlay", {
           kind: "message",
-          payload: resolved.trim(),
+          payload: routeText,
           ts: Date.now()
         });
         clearInlineImageSlots();
@@ -2302,7 +2337,7 @@ var InputPrompt = memo2(({
     return { lines, cursorLine, cursorCol, totalLines: lines.length };
   }, [text, cursorPosition]);
   const displayData = linesData;
-  const placeholder = isReadOnly ? " Press Esc to cancel | Enter message while agent runs" : "";
+  const placeholder = isReadOnly ? " Esc cancel \xB7 / opens slash palette (\u2191\u2193 Tab \xB7 Enter to apply) \xB7 Enter sends" : "";
   const showPlaceholder = text.length === 0 && isReadOnly;
   const slashQuery = useMemo(() => text.startsWith("/") ? text : "", [text]);
   const slashSuggestions = useMemo(() => {
@@ -2310,7 +2345,7 @@ var InputPrompt = memo2(({
     return filterSlashCommands(slashQuery);
   }, [slashQuery]);
   useEffect3(() => {
-    if (isReadOnly) {
+    if (disableWhileProcessing) {
       setSlashOpen(false);
       wasSlashMenuOpenRef.current = false;
       return;
@@ -2326,31 +2361,41 @@ var InputPrompt = memo2(({
       wasSlashMenuOpenRef.current = false;
       setSlashOpen(false);
     }
-  }, [text, isReadOnly]);
+  }, [text, disableWhileProcessing]);
   useEffect3(() => {
     if (!slashOpen || slashSuggestions.length === 0) return;
     setSlashIndex((i) => Math.min(i, slashSuggestions.length - 1));
   }, [slashOpen, slashSuggestions.length, slashQuery]);
+  useLayoutEffect(() => {
+    const open = slashOpen && slashSuggestions.length > 0 && !disableWhileProcessing && !permissionDialogOpen;
+    globalThis.__BLUMA_SLASH_MENU_OPEN__ = open;
+    return () => {
+      globalThis.__BLUMA_SLASH_MENU_OPEN__ = false;
+    };
+  }, [slashOpen, slashSuggestions.length, disableWhileProcessing, permissionDialogOpen]);
+  const applySlashChoice = (choice) => {
+    if (!choice) return;
+    setSlashOpen(false);
+    try {
+      setText(`${choice.name} `);
+    } catch {
+      permissiveOnSubmit(`${choice.name} `);
+    }
+  };
   useInput2((input, key) => {
-    if (!slashOpen) return;
+    if (!slashOpen || slashSuggestions.length === 0) return;
     if (key.downArrow) {
       setSlashIndex((i) => Math.min(i + 1, Math.max(0, slashSuggestions.length - 1)));
     } else if (key.upArrow) {
       setSlashIndex((i) => Math.max(i - 1, 0));
     } else if (key.return) {
-      const choice = slashSuggestions[slashIndex];
-      if (choice) {
-        setSlashOpen(false);
-        try {
-          setText(`${choice.name} `);
-        } catch (e) {
-          permissiveOnSubmit(`${choice.name} `);
-        }
-      }
+      applySlashChoice(slashSuggestions[slashIndex]);
+    } else if (key.tab) {
+      applySlashChoice(slashSuggestions[slashIndex]);
     } else if (key.escape) {
       setSlashOpen(false);
     }
-  }, { isActive: slashOpen && !permissionDialogOpen });
+  }, { isActive: slashOpen && slashSuggestions.length > 0 && !permissionDialogOpen && !disableWhileProcessing });
   useEffect3(() => {
     if (globalThis.__BLUMA_FORCE_CURSOR_END__) {
       setText(text, text.length);
@@ -6939,7 +6984,24 @@ function readSessionLog(sessionId) {
 }
 
 // src/app/agent/tools/natives/agent_coordination.ts
-function buildWorkerPayload(sessionId, args, parentSessionId) {
+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,
@@ -6952,6 +7014,7 @@ function buildWorkerPayload(sessionId, args, parentSessionId) {
       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,
@@ -6995,8 +7058,9 @@ async function spawnAgent(args) {
   }
   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);
+  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");
@@ -7012,7 +7076,9 @@ async function spawnAgent(args) {
       background: true,
       coordinator_worker: true,
       parent_session_id: parentSessionId,
-      agent_type: args.agent_type || "worker"
+      agent_type: args.agent_type || "worker",
+      user_id: userContext?.userId ?? null,
+      company_id: userContext?.companyId ?? null
     }
   });
   const child = spawn4(
@@ -8635,6 +8701,212 @@ function getPlugin(name) {
   return listPlugins().find((plugin) => plugin.name === q) || null;
 }
 
+// src/app/agent/utils/coordinator_prompt.ts
+var COORDINATOR_SYSTEM_PROMPT = `
+# BluMa Coordinator Mode
+
+You are the **BluMa Coordinator** - a worker orchestrator for software engineering.
+
+## 1. Your Role
+
+You do **NOT execute tasks directly**. Your job is to:
+- **Orchestrate workers** to research, implement, and verify changes
+- **Synthesize results** and communicate with the user
+- **Answer questions directly** when possible \u2014 don't delegate work you can handle without tools
+- **Read-only tools** (\`read_file_lines\`, \`grep\`, etc.) are fine for **light** coordinator checks (e.g. verify a path before writing a worker spec); heavy exploration belongs in workers
+- **Break complex tasks** into parallelizable work items
+
+Every message you send is to the **user**. Worker results are internal notifications.
+
+## 2. Your Main Tools
+
+| Tool | Usage |
+|------|-------|
+| \`spawn_agent\` | Create a new worker |
+| \`wait_agent\` | Wait for worker completion |
+| \`list_agents\` | List active/completed workers |
+
+### Tool contract (BluMa)
+
+- \`spawn_agent\` returns JSON with \`session_id\` (and \`success\`). That id is the only stable handle for follow-up.
+- 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).
+
+### When to call \`spawn_agent\`:
+
+- **Research**: "Investigate the authentication structure"
+- **Implementation**: "Implement feature X in file Y"
+- **Verification**: "Run tests and verify they pass"
+- **Refactoring**: "Refactor module Z to use modern patterns"
+
+**Concurrency Tip**: Launch **independent workers in parallel** whenever possible.
+
+## 3. Task Workflow
+
+### Phases
+
+| Phase | Who | Purpose |
+|-------|-----|---------|
+| **Research** | Workers (parallel) | Investigate codebase, find files, understand problem |
+| **Synthesis** | **You** (coordinator) | Read findings, understand problem, craft implementation specs |
+| **Implementation** | Workers | Make targeted changes per spec, commit |
+| **Verification** | Workers | Test changes work |
+
+### Concurrency is Your Superpower
+
+**Workers are async.** Launch independent tasks **concurrently** - don't serialize work that can run in parallel.
+
+**Manage concurrency:**
+- Read-only tasks (research) - run in parallel freely
+- Write-heavy tasks (implementation) - one at a time per file set
+- Verification can run alongside implementation on different file areas
+
+## 4. Writing Worker Prompts
+
+**Workers CANNOT see your conversation.** Every prompt must be **self-contained** with everything the worker needs.
+
+### ALWAYS Synthesize - Your Most Important Job
+
+When workers report research findings, **you must understand them before directing follow-up**.
+
+**NEVER write:**
+- "Based on your findings, implement the fix"
+- "The worker found an issue in the auth module. Please fix it."
+
+**ALWAYS write:**
+- "Fix the null pointer in src/auth/validate.ts:42. The user field is undefined when Session.expired is true but the token is still cached. Add a null check before accessing user.id - if null, return 401 with 'Session expired'. Commit and report the hash."
+
+### Add a Purpose Statement
+
+Include a brief purpose so workers can calibrate depth:
+- "This research will inform a PR description - focus on user-facing changes."
+- "I need this to plan an implementation - report file paths, line numbers, and type signatures."
+- "This is a quick check before we merge - just verify the happy path."
+
+### Continue vs Spawn Fresh
+
+| Situation | Mechanism | Why |
+|-----------|-----------|-----|
+| Research explored exactly the files that need editing | **Continue** (wait + new prompt) | Worker already has files in context + now gets a clear plan |
+| Research was broad but implementation is narrow | **Spawn fresh** | Avoid dragging along exploration noise; focused context is cleaner |
+| Correcting a failure or extending recent work | **Continue** | Worker has the error context and knows what it just tried |
+| Verifying code a different worker just wrote | **Spawn fresh** | Verifier should see the code with fresh eyes |
+| First implementation used the wrong approach entirely | **Spawn fresh** | Wrong-approach context pollutes the retry |
+| Completely unrelated task | **Spawn fresh** | No useful context to reuse |
+
+**There is no universal default.** Think about how much of the worker's context overlaps with the next task.
+
+### Prompt Examples
+
+**Good examples:**
+
+1. **Implementation**: "Fix the null pointer in src/auth/validate.ts:42. The user field can be undefined when the session expires. Add a null check and return early with an appropriate error. Commit and report the hash."
+
+2. **Precise git operation**: "Create a new branch from main called 'fix/session-expiry'. Cherry-pick only commit abc123 onto it. Push and create a draft PR targeting main. Add reviewers. Report the PR URL."
+
+3. **Correction (continued worker, short)**: "Two tests still failing at lines 58 and 72 - update the assertions to match the new error message."
+
+**Bad examples:**
+
+1. "Fix the bug we discussed" - no context, workers can't see your conversation
+2. "Based on your findings, implement" - lazy delegation; synthesize the findings yourself
+3. "Create a PR for the recent changes" - ambiguous scope: which changes? which branch?
+4. "Something went wrong with the tests, can you look?" - no error message, no file path, no direction
+
+## 5. What Real Verification Looks Like
+
+Verification means **proving the code works**, not confirming it exists.
+
+- Run tests **with the feature enabled** - not just "tests pass"
+- Run typechecks and **investigate errors** - don't dismiss as "unrelated"
+- Be skeptical - if something looks off, dig in
+- **Test independently** - prove the change works, don't rubber-stamp
+
+## 6. Example Session
+
+**User**: "There's a null pointer in the auth module. Can you fix it?"
+
+**You (Coordinator)**:
+\`\`\`
+Let me investigate first.
+
+spawn_agent({
+  task: "Investigate the auth module in src/auth/. Find where null pointer exceptions could occur around session handling and token validation. Report specific file paths, line numbers, and types involved. Do NOT modify files.",
+  title: "Research: Auth Bug Investigation",
+  agent_type: "researcher"
+})
+
+spawn_agent({
+  task: "Find all test files related to src/auth/. Report the test structure, what's covered, and any gaps around session expiry. Do NOT modify files.",
+  title: "Research: Auth Test Coverage",
+  agent_type: "researcher"
+})
+
+Investigating from two angles - I'll report back with findings.
+\`\`\`
+
+**You** call \`wait_agent({ session_id: "<id-from-spawn>", timeout_ms: 600000 })\` for each research worker. Tool result shape is JSON, e.g. \`completed: true\`, \`session\` summary, and \`result\` with the worker's last structured output \u2014 **synthesize from that**, not from a fictional XML envelope.
+
+**After workers finish**, you have concrete paths and line numbers from their \`result\` / messages.
+
+**You (Coordinator)**:
+\`\`\`
+Found the bug - null pointer in validate.ts:42.
+
+spawn_agent({
+  task: "Fix the null pointer in src/auth/validate.ts:42. Add a null check before accessing user.id - if null, return 401 with 'Session expired'. Run relevant tests and typecheck. Commit and report the hash.",
+  title: "Fix: Auth Null Pointer",
+  agent_type: "implementer"
+})
+
+Fix in progress.
+\`\`\`
+
+**User**: "How's it going?"
+
+**You**:
+\`\`\`
+Fix for the null pointer in progress. Waiting for worker to complete tests and commit.
+\`\`\`
+
+## 7. Final Tips
+
+### Parallelism Tips
+- Launch 2-4 research workers in parallel
+- Group implementations by file/module
+- Verification can be parallel if testing different modules
+
+### Communication Tips
+- Always tell the user what you launched
+- Don't fabricate or predict worker results
+- Summarize new information as it arrives from workers
+- Be transparent about progress
+
+### Quality Tips
+- Synthesis > lazy delegation
+- Specific > vague
+- File paths + line numbers > "in module X"
+- "Prove it works" > "Confirm it exists"
+
+---
+
+**Remember**: You are a **Coordinator**. Your value is in **intelligent orchestration** and **synthesis**; delegate implementation and deep exploration to workers whenever that reduces risk or speeds parallel work.
+`;
+function getCoordinatorSystemPrompt() {
+  return COORDINATOR_SYSTEM_PROMPT;
+}
+function isCoordinatorModeEnabled() {
+  return process.env.BLUMA_COORDINATOR_MODE === "true";
+}
+function enableCoordinatorMode() {
+  process.env.BLUMA_COORDINATOR_MODE = "true";
+}
+function disableCoordinatorMode() {
+  delete process.env.BLUMA_COORDINATOR_MODE;
+}
+
 // src/app/agent/core/prompt/prompt_builder.ts
 function getNodeVersion() {
   try {
@@ -8769,9 +9041,12 @@ function buildCoordinatorModePrompt(mode) {
   if (mode !== "coordinator") {
     return "";
   }
+  const playbook = getCoordinatorSystemPrompt().trim();
   return `
 <coordinator_mode>
-**Coordinator mode** is active: prefer delegating bounded work to \`spawn_agent\` with a crisp objective and inputs, then \`wait_agent\` / \`list_agents\` to collect results. Use \`message\` (\`info\`) to narrate coordination. Avoid direct \`edit_tool\` / \`file_write\` when a subagent can own the implementation; do shallow delegation (do not assume nested hidden workers). Ground every summary in actual tool outputs.
+**Runtime: coordinator mode is active.** The following playbook is binding.
+
+${playbook}
 </coordinator_mode>
 `;
 }
@@ -10114,6 +10389,14 @@ var BluMaAgent = class {
       turnId,
       sessionId: userContextInput.sessionId || this.sessionId
     };
+    process.env.BLUMA_USER_CONTEXT_JSON = JSON.stringify({
+      conversationId: this.activeTurnContext.conversationId ?? null,
+      userId: this.activeTurnContext.userId ?? null,
+      userName: this.activeTurnContext.userName ?? null,
+      userEmail: this.activeTurnContext.userEmail ?? null,
+      companyId: this.activeTurnContext.companyId ?? null,
+      companyName: this.activeTurnContext.companyName ?? null
+    });
     const userContent = buildUserMessageContent(inputText, process.cwd());
     this.history.push({ role: "user", content: userContent });
     this.emptyAssistantReplySteps = 0;
@@ -11475,8 +11758,67 @@ var Agent = class {
     if (inputText === "/init" || inputText.startsWith("/init ")) {
       this.routeManager.registerRoute("/init", this.dispatchToSubAgent);
     }
+    if (inputText === "/coordinator" || inputText.startsWith("/coordinator ")) {
+      this.routeManager.registerRoute("/coordinator", this.handleCoordinatorCommand.bind(this));
+    }
     await this.routeManager.handleRoute({ content: inputText, userContext: resolvedUserContext });
   }
+  /**
+   * Handler para o comando /coordinator
+   * /coordinator enable  - Ativa o Coordinator Mode
+   * /coordinator disable - Desativa o Coordinator Mode
+   * /coordinator status  - Mostra status atual
+   * /coordinator         - Toggle (ativa se desativado, desativa se ativado)
+   */
+  async handleCoordinatorCommand(payload) {
+    const inputText = payload.content.trim();
+    const args = inputText.split(/\s+/).slice(1);
+    const subcommand = args[0]?.toLowerCase();
+    let message2;
+    let messageType = "info";
+    switch (subcommand) {
+      case "enable":
+        enableCoordinatorMode();
+        message2 = "\u2705 Coordinator Mode ATIVADO!\n\nO BluMa agora atuar\xE1 como Coordinator - orquestrando workers em vez de executar diretamente.\n\nUse spawn_agent() para delegar tarefas, wait_agent() para aguardar resultados, e list_agents() para gerenciar workers.";
+        messageType = "success";
+        break;
+      case "disable":
+        disableCoordinatorMode();
+        message2 = "\u23F9\uFE0F Coordinator Mode DESATIVADO.\n\nO BluMa voltar\xE1 ao modo padr\xE3o de execu\xE7\xE3o direta.";
+        messageType = "info";
+        break;
+      case "status":
+      case "info":
+        const status = isCoordinatorModeEnabled() ? "\u2705 ATIVO" : "\u274C INATIVO";
+        message2 = `\u{1F4CA} Coordinator Mode Status: ${status}
+
+Quando ativo, o BluMa atua como Coordinator - orquestrando workers para:
+\u2022 Pesquisa paralela (m\xFAltiplos workers investigando diferentes aspectos)
+\u2022 Implementa\xE7\xE3o delegada (workers especializados por m\xF3dulo)
+\u2022 Verifica\xE7\xE3o independente (workers testam mudan\xE7as de outros workers)
+
+Tools principais:
+\u2022 spawn_agent() - Criar worker
+\u2022 wait_agent() - Aguardar conclus\xE3o
+\u2022 list_agents() - Listar workers ativos`;
+        break;
+      default:
+        if (isCoordinatorModeEnabled()) {
+          disableCoordinatorMode();
+          message2 = "\u23F9\uFE0F Coordinator Mode DESATIVADO (toggle).";
+          messageType = "info";
+        } else {
+          enableCoordinatorMode();
+          message2 = '\u2705 Coordinator Mode ATIVADO!\n\nOrquestrando workers em vez de executar diretamente.\nDica: Use "help" para ver exemplos de como usar spawn_agent().';
+          messageType = "success";
+        }
+    }
+    this.eventBus.emit("backend_message", {
+      type: messageType,
+      code: "coordinator_mode",
+      message: message2
+    });
+  }
   async handleToolResponse(decisionData) {
     await this.core.handleToolResponse(decisionData);
   }
@@ -13543,6 +13885,32 @@ var SlashCommands = ({
     if (cmd === "sessions") {
       return showSessions();
     }
+    if (cmd === "agents") {
+      const entries = listSessions().filter((e) => e.kind === "agent");
+      if (entries.length === 0) {
+        return outBox(
+          /* @__PURE__ */ jsxs15(Fragment6, { children: [
+            /* @__PURE__ */ jsx17(Text15, { bold: true, color: BLUMA_TERMINAL.claude, children: "Worker agents" }),
+            /* @__PURE__ */ jsx17(Text15, { dimColor: true, children: " No agent sessions in this CLI registry. Use the " }),
+            /* @__PURE__ */ jsx17(Text15, { bold: true, children: "spawn_agent" }),
+            /* @__PURE__ */ jsx17(Text15, { dimColor: true, children: " tool from chat, or " }),
+            /* @__PURE__ */ jsx17(Text15, { bold: true, children: "/agent coordinator" }),
+            /* @__PURE__ */ jsx17(Text15, { dimColor: true, children: " then ask the model to delegate." })
+          ] })
+        );
+      }
+      return outBox(
+        /* @__PURE__ */ jsxs15(Fragment6, { children: [
+          /* @__PURE__ */ jsx17(Text15, { bold: true, color: BLUMA_TERMINAL.claude, children: "Worker agents" }),
+          /* @__PURE__ */ jsxs15(Text15, { dimColor: true, children: [
+            " ",
+            entries.length,
+            " session(s)"
+          ] }),
+          /* @__PURE__ */ jsx17(Box16, { marginTop: 1, flexDirection: "column", children: entries.map((e) => /* @__PURE__ */ jsx17(Text15, { dimColor: true, wrap: "wrap", children: formatSessionLine(e) }, e.sessionId)) })
+        ] })
+      );
+    }
     if (cmd === "bridge") {
       return renderBridgePanel();
     }
@@ -13624,7 +13992,9 @@ var SlashCommands = ({
       const cfg = getRuntimeConfig();
       return usageBox(
         "Agent mode",
-        `current: ${cfg.agentMode} \xB7 set: /agent default | /agent coordinator`
+        `current: ${cfg.agentMode}
+set: /agent default | /agent coordinator
+(list workers: /agents \u2014 not the same as /agent)`
       );
     }
     if (cmd === "features") {
@@ -14455,7 +14825,20 @@ var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
   }, [isProcessing, eventBus]);
   const handleSubmit = useCallback3(
     (text) => {
-      if (!text || isProcessing || !agentInstance.current) return;
+      if (!text || !agentInstance.current) return;
+      const trimmedForSlash = text.trim();
+      if (isProcessing && !isSlashRoutingLine(trimmedForSlash)) {
+        if (trimmedForSlash.startsWith("/")) {
+          setHistory((prev) => [
+            ...prev,
+            {
+              id: prev.length,
+              component: /* @__PURE__ */ jsx24(ChatMeta, { children: "Slash command not recognized or incomplete. Type /help for the list." })
+            }
+          ]);
+        }
+        return;
+      }
       lastReasoningTextRef.current = null;
       lastStreamAssistantKeyRef.current = null;
       if (/^\/img\s+/i.test(text) || /^\/image\s+/i.test(text)) {
@@ -14896,11 +15279,21 @@ Please use command_status to check the result and report back to the user.`;
     const handleUiOverlay = (data) => {
       eventBus.emit("user_overlay", data);
     };
+    const handleInputNotice = (data) => {
+      const msg = String(data.message || "").trim();
+      if (!msg) return;
+      setHistory((prev) => [
+        ...prev,
+        { id: prev.length, component: /* @__PURE__ */ jsx24(ChatMeta, { children: msg }) }
+      ]);
+    };
     uiEventBus.on("user_overlay", handleUiOverlay);
+    uiEventBus.on("input_notice", handleInputNotice);
     eventBus.on("backend_message", handleBackendMessage);
     initializeAgent();
     return () => {
       uiEventBus.off("user_overlay", handleUiOverlay);
+      uiEventBus.off("input_notice", handleInputNotice);
       eventBus.off("backend_message", handleBackendMessage);
     };
   }, [eventBus, sessionId, handleConfirmation]);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nomad-e/bluma-cli",
-	"version": "0.1.45",
+	"version": "0.1.46",
 	"description": "BluMa independent agent for automation and advanced software engineering.",
 	"author": "Alex Fonseca",
 	"license": "Apache-2.0",