@nomad-e/bluma-cli 0.1.74 → 0.1.75

package/README.md

@@ -11,7 +11,7 @@
 
 > **Credit:** BluMa was conceived and architected by **Alex Fonseca**.
 
-**Current Version:** 0.1.60
+**Current Version:** 0.1.74
 
 ---
 
@@ -42,7 +42,7 @@ BluMa operates as a **conversational agent** in the terminal, combining:
 - **Rich UI Layer**: React/Ink 5 components for interactive prompts, live overlays, and real-time feedback
 - **Agent Layer**: LLM orchestration via FactorRouter with tool invocation and context management
 - **Runtime Layer**: Task tracking, plugin system, hooks, diagnostics, session management, and coordinator mode
-- **Tool Layer**: 40+ native tools + MCP SDK integration for external tools
+- **Tool Layer**: 45+ native tools + MCP SDK integration for external tools
 
 The agent maintains persistent conversation history, workspace snapshots, and coding memory across sessions.
 
@@ -67,7 +67,7 @@ The agent maintains persistent conversation history, workspace snapshots, and co
 - **Tool Execution Policy**: Intelligent decisions based on sandbox mode and safety
 
 ### Tools & Skills
-- **40+ Native Tools**: File operations, search, shell commands, web fetch, agent coordination, task management, MCP resources, cron scheduling, LSP queries, notebook editing
+- **45+ Native Tools**: File operations, search, shell commands, web fetch, agent coordination, task management, MCP resources, cron scheduling, LSP queries, notebook editing
 - **Coordinator Mode**: Orchestrator playbook for delegating work to background workers
 - **MCP Integration**: Model Context Protocol SDK for external tool servers
 - **Skills System**: Pluggable knowledge modules (git, PDF, Excel, etc.)
@@ -237,7 +237,7 @@ npm start
 ┌────────────────────────┼────────────────────────────────────┐
 │                    Tools Layer                              │
 │  ┌──────────────────────────────────────────────────────┐  │
-│  │              Native Tools (40+)                      │  │
+│  │              Native Tools (45+)                      │  │
 │  │  edit_tool, file_write, shell_command, grep_search,  │  │
 │  │  spawn_agent, wait_agent, list_agents,               │  │
 │  │  todo, task_boundary, task_create, task_list,        │  │
@@ -260,7 +260,7 @@ npm start
 
 ## Native Tools
 
-BluMa includes **40+ built-in tools** organized by category:
+BluMa includes **45+ built-in tools** organized by category:
 
 ### File Operations
 | Tool | Description |
@@ -341,6 +341,18 @@ BluMa includes **40+ built-in tools** organized by category:
 | `repl` | Interactive code execution (Python, Node, Bash) |
 | `task_output` | Read task output in real-time |
 
+### Specialized
+| Tool | Description |
+|------|-------------|
+| `context_collapse` | Collapse context window |
+| `dream_engine` | Auto-dream feature (coding memory consolidation) |
+| `brief` | Generate project brief |
+| `ctx_inspect` | Inspect current context |
+| `snip` | Code snippet management |
+| `coordinator_tools` | Coordinator mode utilities |
+| `create-next-app` | Scaffold Next.js project with shadcn/ui + Tailwind |
+| `deploy-app` | Deploy Next.js to Severino hosting |
+
 ### Plan Mode
 | Tool | Description |
 |------|-------------|
@@ -349,7 +361,7 @@ BluMa includes **40+ built-in tools** organized by category:
 
 ---
 
-## New Features in v0.1.60
+## Current Features
 
 ### Mailbox System (Bidirectional Communication)
 **Push-based communication** between coordinator and workers using EventEmitter:
@@ -570,6 +582,7 @@ Level 3b: scripts/*.py
 |-------|-------------|
 | `git-commit` | Conventional commits, staging, commit messages |
 | `git-pr` | Pull requests, code review preparation |
+| `git-release` | Version bumps, changelogs, git tags, GitHub releases |
 | `pdf` | PDF creation, extraction, merging, OCR |
 | `xlsx` | Spreadsheet operations, formulas, charts |
 | `skill-creator` | Author new BluMa skills |
@@ -765,11 +778,29 @@ src/
 │   │   ├── agent.ts                    # Main orchestrator
 │   │   ├── bluma/                      # Core agent logic
 │   │   │   ├── core/
-│   │   │   │   └── bluma.ts            # BluMaAgent class
-│   │   │   └── turn_start_payload.ts   # Backend turn payload
+│   │   │   │   ├── bluma.ts            # BluMaAgent class
+│   │   │   │   └── turn_start_payload.ts
+│   │   │   ├── context/
+│   │   │   │   └── auto_compact.ts     # Automatic context compaction
+│   │   │   ├── memory/
+│   │   │   │   └── session_memory.ts   # Session memory
+│   │   │   └── types/
+│   │   │       └── errors.ts           # Error type definitions
 │   │   ├── config/
-│   │   │   ├── native_tools.json       # Tool definitions (40+)
-│   │   │   └── skills/                 # Bundled skills (git-commit, git-pr, pdf, xlsx, skill-creator)
+│   │   │   ├── native_tools.json       # Tool definitions (45+)
+│   │   │   ├── skills/                 # Bundled skills
+│   │   │   │   ├── git-commit/
+│   │   │   │   ├── git-pr/
+│   │   │   │   ├── git-release/        # Version bumps, changelogs, releases
+│   │   │   │   ├── pdf/
+│   │   │   │   ├── skill-creator/
+│   │   │   │   └── xlsx/
+│   │   │   │       └── scripts/
+│   │   │   │           └── office/     # Office document handling
+│   │   │   │               ├── pack.py
+│   │   │   │               ├── unpack.py
+│   │   │   │               ├── validate.py
+│   │   │   │               └── soffice.py
 │   │   ├── core/                       # LLM, context, prompts
 │   │   │   ├── context-api/            # Context management
 │   │   │   │   ├── context_manager.ts  # Token-aware context
@@ -777,17 +808,32 @@ src/
 │   │   │   │   └── token_counter.ts    # Tiktoken integration
 │   │   │   ├── llm/                    # LLM client
 │   │   │   │   ├── llm.ts              # FactorRouter client
+│   │   │   │   ├── llm_errors.ts       # LLM error formatting
+│   │   │   │   ├── streaming_delta.ts  # Streaming delta handling
 │   │   │   │   └── tool_call_normalizer.ts
-│   │   │   └── prompt/                 # Prompt engineering
-│   │   │       ├── prompt_builder.ts   # Dynamic prompts
-│   │   │       └── workspace_snapshot.ts
+│   │   │   ├── prompt/                 # Prompt engineering
+│   │   │   │   ├── prompt_builder.ts   # Dynamic prompts
+│   │   │   │   ├── workspace_snapshot.ts
+│   │   │   │   ├── mcp_instructions.ts
+│   │   │   │   ├── model_info.ts
+│   │   │   │   ├── production_sandbox_prompt.ts
+│   │   │   │   ├── system_prompt_sections.ts
+│   │   │   │   ├── system_reminders.ts
+│   │   │   │   └── tool_guidance.ts
+│   │   │   └── context_viz.ts          # Context visualization
+│   │   ├── docs/
+│   │   │   └── TOOL_PARITY.md          # Tool parity documentation
 │   │   ├── feedback/
 │   │   │   └── feedback_system.ts      # Smart feedback system
+│   │   │   └── feedback_scoring.ts     # User feedback scoring
 │   │   ├── runtime/                    # Orchestration layer (v0.1.41+)
 │   │   │   ├── diagnostics.ts          # System snapshots
 │   │   │   ├── feature_flags.ts        # Feature gates
 │   │   │   ├── hook_registry.ts        # Event-driven hooks
 │   │   │   ├── native_tool_catalog.ts  # Tool registry
+│   │   │   ├── permission_bridge.ts    # Leader↔Worker permission system
+│   │   │   ├── permission_rules.ts     # Permission rule definitions
+│   │   │   ├── tool_permission_classifier.ts
 │   │   │   ├── plan_mode_session.ts    # Plan mode state
 │   │   │   ├── plugin_registry.ts      # Plugin system
 │   │   │   ├── plugin_runtime.ts       # Plugin execution
@@ -799,21 +845,29 @@ src/
 │   │   │   ├── tool_auto_approve.ts    # Auto-approve rules
 │   │   │   ├── tool_execution_policy.ts
 │   │   │   ├── tool_orchestration.ts   # Parallel read eligibility
-│   │   │   └── tool_permission_classifier.ts
+│   │   │   ├── mailbox_registry.ts     # Mailbox system
+│   │   │   ├── worker_context.ts       # Worker context management
+│   │   │   └── factorai_context.ts     # FactorAI app context
 │   │   ├── session_manager/
 │   │   │   └── session_manager.ts      # Session persistence
 │   │   ├── skills/
-│   │   │   └── skill_loader.ts         # Skill loading
+│   │   │   └── skill_loader.ts         # 3-source skill loading
 │   │   ├── subagents/                  # Subagent system
 │   │   │   ├── base_llm_subagent.ts
 │   │   │   ├── init/                   # Init subagent (BluMa.md)
+│   │   │   │   ├── init_subagent.ts    # Deep project analysis
+│   │   │   │   ├── init_system_prompt.ts
+│   │   │   │   └── contracts.ts
 │   │   │   ├── registry.ts
-│   │   │   ├── subagents_bluma.ts
-│   │   │   └── types.ts
+│   │   │   ├── subagents_bluma.ts      # SubAgent orchestration
+│   │   │   ├── types.ts                # SubAgent type definitions
+│   │   │   └── worker_system_prompt.ts
 │   │   ├── tools/
 │   │   │   ├── mcp/
 │   │   │   │   └── mcp_client.ts       # MCP SDK client
-│   │   │   └── natives/                # 27 native tool implementations
+│   │   │   ├── shared/
+│   │   │   │   └── token_utils.ts      # Token utilities
+│   │   │   └── natives/                # 45+ native tool implementations
 │   │   │       ├── agent_coordination.ts
 │   │   │       ├── ask_user_question.ts
 │   │   │       ├── async_command.ts
@@ -844,29 +898,35 @@ src/
 │   │   ├── types/
 │   │   │   └── index.ts
 │   │   └── utils/
+│   │       ├── blumamd.ts              # BluMa markdown utilities
 │   │       ├── coordinator_prompt.ts   # Coordinator mode playbook
+│   │       ├── logger.ts               # Logging utilities
 │   │       ├── update_check.ts
 │   │       └── user_message_images.ts
 │   └── ui/
 │       ├── App.tsx                     # Main UI component
 │       ├── Asci/
 │       │   └── AsciiArt.ts
-│       ├── components/                 # 24+ UI components
+│       ├── components/                 # 25+ UI components
 │       │   ├── AnimatedBorder.tsx
 │       │   ├── AskUserQuestionPrompt.tsx
 │       │   ├── AssistantMessageDisplay.tsx
 │       │   ├── CollapsibleResult.tsx
+│       │   ├── ConfirmationPrompt.tsx  # Permission confirmation dialog
 │       │   ├── EditToolDiffPanel.tsx   # Diff preview for edits
 │       │   ├── ErrorMessage.tsx
 │       │   ├── ExpandedPreviewBlock.tsx
 │       │   ├── InputPrompt.tsx         # User input
+│       │   ├── InteractiveMenu.tsx     # Interactive menu component
 │       │   ├── MarkdownRenderer.tsx
 │       │   ├── ProgressBar.tsx
 │       │   ├── ReasoningDisplay.tsx    # LLM reasoning
+│   │   │   ├── SessionInfoConnectingMCP.tsx
 │       │   ├── SessionStats.tsx
 │       │   ├── SimpleDiff.tsx
 │       │   ├── SlashCommands.tsx       # 30+ commands
 │       │   ├── StatusNotification.tsx
+│       │   ├── StartupUpdateGate.tsx   # Update check gate
 │       │   ├── StreamingText.tsx       # Live text output
 │       │   ├── TodoPlanDisplay.tsx     # Task visualization
 │       │   ├── ToolCallDisplay.tsx
@@ -875,17 +935,41 @@ src/
 │       │   ├── ToolResultDisplay.tsx
 │       │   ├── TypewriterText.tsx
 │       │   ├── UpdateNotice.tsx
+│       │   ├── WorkerOverlay.tsx       # Worker status overlay
+│       │   ├── WorkerStatusList.tsx    # Active workers list
+│       │   ├── WorkerTranscript.tsx    # Worker conversation transcript
+│       │   ├── WorkingTimer.tsx        # Work duration timer
 │       │   ├── streamingTextFlush.ts
 │       │   └── toolCallRenderers.tsx
 │       ├── constants/
-│       │   ├── historyLayout.ts
-│       │   ├── inputPaste.ts
-│       │   └── toolUiPreview.ts
+│       │   ├── historyLayout.ts        # History layout constants
+│       │   ├── inputPaste.ts           # Input paste constants
+│       │   └── toolUiPreview.ts        # Tool UI preview constants
+│       │   └── toolUiSymbols.ts        # Tool UI symbols
 │       ├── hooks/
-│       │   └── useAtCompletion.ts
+│       │   ├── useAtCompletion.ts      # Completion hook
+│       │   └── useWorkerProgress.ts    # Worker progress hook
+│       ├── prompts/
+│       │   └── initCommandPrompt.ts    # Init command prompt
+│       ├── slash-commands/
+│       │   ├── SlashCommands.types.ts  # Type definitions
+│       │   ├── commandHelpers.tsx      # Command helpers
+│       │   ├── constants.ts            # Slash command constants
+│       │   ├── SessionLivePanel.tsx    # Session live panel
+│       │   ├── streamingTextFlush.ts   # Streaming text flush
+│       │   └── renderers/
+│       │       ├── index.ts
+│       │       ├── configRenderers.tsx
+│       │       ├── infoRenderers.tsx
+│       │       ├── permissionRenderers.tsx
+│       │       ├── pluginRenderers.tsx
+│       │       ├── sessionRenderers.tsx
+│       │       ├── staticRenderers.tsx
+│       │       └── taskRenderers.tsx
 │       ├── theme/
 │       │   ├── blumaTerminal.ts
-│       │   └── m3Layout.tsx
+│       │   ├── themes.ts               # Theme definitions
+│       │   └── m3Layout.tsx            # Material Design 3 layout
 │       └── utils/
 │           ├── clipboardImage.ts
 │           ├── editToolDiffUtils.ts
@@ -896,8 +980,9 @@ src/
 │           ├── pathDisplay.ts
 │           ├── shellToolNames.ts
 │           ├── slashRegistry.ts
-│           ├── terminalTitle.ts
-│           ├── toolDisplayLabels.ts
+│           ├── terminalTitle.ts        # Terminal title keeper
+│           ├── toolActionLabels.ts     # Tool action labels
+│           ├── toolDisplayLabels.ts    # Tool display labels
 │           ├── toolInvocationPairing.ts
 │           └── useSimpleInputBuffer.ts
 ├── main.ts                             # Entry point
@@ -917,7 +1002,7 @@ npm run test:watch  # Watch mode
 ### Test Structure
 
 ```
-tests/                    # 33 test files (flat structure)
+tests/                    # 35+ test files (flat structure)
 ├── agent_*.spec.ts       # Agent routing, overlays, coordination
 ├── edit_tool.spec.ts     # File editing operations
 ├── file_write.spec.ts    # File write operations
@@ -939,6 +1024,9 @@ tests/                    # 33 test files (flat structure)
 ├── web_fetch.spec.ts     # Web fetching
 ├── workspace_snapshot.spec.ts # Workspace analysis
 ├── ui_*.spec.ts(x)       # UI component tests
+├── llm_stream_partial.spec.ts # LLM streaming partial handling
+├── llm_errors.spec.ts    # LLM error handling
+├── jest-resolver.cjs     # Jest resolver configuration
 └── ...                   # Additional integration and unit tests
 ```
 

package/dist/config/native_tools.json

@@ -636,13 +636,13 @@
       "type": "function",
       "function": {
         "name": "search_web",
-        "description": "Search for programming solutions across developer-focused sources: Reddit (programming subreddits), GitHub (issues/discussions), StackOverflow, and X (link only). Use this to find solutions, best practices, and community discussions about errors or implementation approaches.",
+        "description": "Search for programming solutions across developer-focused sources: Reddit (programming subreddits), GitHub (issues/discussions), StackOverflow, and X (link only). Use this to find solutions, best practices, and community discussions about errors or implementation approaches. NEW: Supports domain filtering and rate limiting.",
         "parameters": {
           "type": "object",
           "properties": {
             "query": {
               "type": "string",
-              "description": "Search query, e.g. 'typescript cannot find module', 'react useEffect infinite loop fix'"
+              "description": "Search query, e.g. 'typescript cannot find module', 'react useEffect infinite loop fix'. Must be 2-500 characters."
             },
             "sources": {
               "type": "array",
@@ -664,8 +664,31 @@
             },
             "max_results": {
               "type": "integer",
-              "description": "Maximum total results to return. Default is 10.",
-              "default": 10
+              "description": "Maximum total results to return. Default is 10, max is 50.",
+              "default": 10,
+              "maximum": 50,
+              "minimum": 1
+            },
+            "allowed_domains": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Only include search results from these domains (e.g., ['github.com', 'reddit.com']). Cannot be used with blocked_domains."
+            },
+            "blocked_domains": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Never include search results from these domains (e.g., ['spam-site.com']). Cannot be used with allowed_domains."
+            },
+            "max_uses": {
+              "type": "integer",
+              "description": "Maximum number of sources to search (rate limiting). Default is 8, max is 20.",
+              "default": 8,
+              "maximum": 20,
+              "minimum": 1
             }
           },
           "required": [

package/dist/main.js

@@ -327,7 +327,7 @@ var init_sandbox_policy = __esm({
     BLOCKED_COMMAND_PATTERNS = [
       { pattern: /\bsudo\b/, reason: "Privilege escalation is not allowed." },
       { pattern: /\bsu\b\s/, reason: "User switching is not allowed." },
-      { pattern: /\brm\s+-rf\s+\/\b/, reason: "Deleting root filesystem is blocked." },
+      { pattern: /rm\s+-rf\s+\/\s*$/, reason: "Deleting root filesystem is blocked." },
       { pattern: /\bcurl\b.*\|\s*(bash|sh|zsh)/i, reason: "Pipe-to-shell execution is blocked." },
       { pattern: /\bwget\b.*\|\s*(bash|sh|zsh)/i, reason: "Pipe-to-shell execution is blocked." },
       { pattern: /\beval\b\s*\(/, reason: "Eval execution is blocked." },
@@ -6980,9 +6980,106 @@ async function readArtifact(args) {
 import https from "https";
 import http from "http";
 var DEFAULT_SOURCES = ["reddit", "github", "stackoverflow"];
-var MAX_RESULTS_DEFAULT = 5;
+var MAX_RESULTS_DEFAULT = 10;
+var MAX_USES_DEFAULT = 8;
 var REQUEST_TIMEOUT = 15e3;
 var MAX_CONTENT_LENGTH = 4e3;
+function validateInput(args) {
+  if (!args.query || typeof args.query !== "string") {
+    return { valid: false, error: "query is required and must be a string" };
+  }
+  if (args.query.trim().length < 2) {
+    return { valid: false, error: "query must be at least 2 characters long" };
+  }
+  if (args.query.length > 500) {
+    return { valid: false, error: "query must be less than 500 characters" };
+  }
+  if (args.allowed_domains && args.blocked_domains && args.allowed_domains.length > 0 && args.blocked_domains.length > 0) {
+    return {
+      valid: false,
+      error: "Cannot specify both allowed_domains and blocked_domains in the same request"
+    };
+  }
+  if (args.sources && args.sources.length > 0) {
+    const validSources = ["reddit", "github", "stackoverflow", "x"];
+    for (const source of args.sources) {
+      if (!validSources.includes(source)) {
+        return {
+          valid: false,
+          error: `Invalid source: ${source}. Valid sources are: ${validSources.join(", ")}`
+        };
+      }
+    }
+  }
+  if (args.max_results !== void 0) {
+    if (typeof args.max_results !== "number" || args.max_results < 1) {
+      return { valid: false, error: "max_results must be a positive integer" };
+    }
+    if (args.max_results > 50) {
+      return { valid: false, error: "max_results cannot exceed 50" };
+    }
+  }
+  if (args.max_uses !== void 0) {
+    if (typeof args.max_uses !== "number" || args.max_uses < 1) {
+      return { valid: false, error: "max_uses must be a positive integer" };
+    }
+    if (args.max_uses > 20) {
+      return { valid: false, error: "max_uses cannot exceed 20" };
+    }
+  }
+  const domainRegex = /^[a-zA-Z0-9][a-zA-Z0-9.-]*\.[a-zA-Z]{2,}$/;
+  if (args.allowed_domains) {
+    for (const domain of args.allowed_domains) {
+      if (!domainRegex.test(domain)) {
+        return { valid: false, error: `Invalid domain format: ${domain}` };
+      }
+    }
+  }
+  if (args.blocked_domains) {
+    for (const domain of args.blocked_domains) {
+      if (!domainRegex.test(domain)) {
+        return { valid: false, error: `Invalid domain format: ${domain}` };
+      }
+    }
+  }
+  return { valid: true };
+}
+function extractDomain(url) {
+  try {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname.toLowerCase();
+    const parts = hostname.split(".");
+    if (parts.length >= 2) {
+      return parts.slice(-2).join(".");
+    }
+    return hostname;
+  } catch {
+    return null;
+  }
+}
+function passesDomainFilter(url, allowedDomains, blockedDomains) {
+  const domain = extractDomain(url);
+  if (!domain) {
+    return { passes: false, reason: "Could not extract domain from URL" };
+  }
+  if (allowedDomains && allowedDomains.length > 0) {
+    const isAllowed = allowedDomains.some(
+      (allowed) => domain === allowed.toLowerCase() || domain.endsWith("." + allowed.toLowerCase())
+    );
+    if (!isAllowed) {
+      return { passes: false, reason: `Domain ${domain} not in allowed list` };
+    }
+  }
+  if (blockedDomains && blockedDomains.length > 0) {
+    const isBlocked = blockedDomains.some(
+      (blocked) => domain === blocked.toLowerCase() || domain.endsWith("." + blocked.toLowerCase())
+    );
+    if (isBlocked) {
+      return { passes: false, reason: `Domain ${domain} is in blocked list` };
+    }
+  }
+  return { passes: true };
+}
 function httpGet(url, customHeaders) {
   return new Promise((resolve2, reject) => {
     const protocol = url.startsWith("https") ? https : http;
@@ -7028,17 +7125,29 @@ function cleanContent(text, maxLength = MAX_CONTENT_LENGTH) {
   }
   return cleaned;
 }
-async function searchReddit(query, limit) {
+async function searchReddit(query, limit, allowedDomains, blockedDomains) {
   const results = [];
+  const warnings = [];
   try {
     const subreddits = "programming+webdev+javascript+typescript+python+node+reactjs+learnprogramming+rust+golang+devops";
     const encodedQuery = encodeURIComponent(query);
-    const url = `https://www.reddit.com/r/${subreddits}/search.json?q=${encodedQuery}&sort=relevance&limit=${limit}&restrict_sr=on`;
+    const url = `https://www.reddit.com/r/${subreddits}/search.json?q=${encodedQuery}&sort=relevance&limit=${limit * 2}&restrict_sr=on`;
+    const domainCheck = passesDomainFilter(url, allowedDomains, blockedDomains);
+    if (!domainCheck.passes) {
+      warnings.push(`Reddit search skipped: ${domainCheck.reason}`);
+      return results;
+    }
     const response = await httpGet(url);
     const data = JSON.parse(response);
     if (data.data?.children) {
-      for (const child of data.data.children.slice(0, limit)) {
+      for (const child of data.data.children.slice(0, limit * 2)) {
+        if (results.length >= limit) break;
         const post = child.data;
+        const postUrl = `https://reddit.com${post.permalink}`;
+        const urlCheck = passesDomainFilter(postUrl, allowedDomains, blockedDomains);
+        if (!urlCheck.passes) {
+          continue;
+        }
         let content = `# ${post.title}
 
 `;
@@ -7070,7 +7179,7 @@ ${cleanContent(post.selftext, 2e3)}
         }
         results.push({
           title: post.title || "",
-          url: `https://reddit.com${post.permalink}`,
+          url: postUrl,
           source: "reddit",
           content: cleanContent(content),
           score: post.score,
@@ -7084,18 +7193,34 @@ ${cleanContent(post.selftext, 2e3)}
     }
   } catch (error) {
     console.error(`[search_web] Reddit error: ${error.message}`);
+    if (error.message.includes("403") || error.message.includes("429")) {
+      warnings.push("Reddit rate limit encountered - results may be incomplete");
+    }
   }
   return results;
 }
-async function searchGitHub(query, limit) {
+async function searchGitHub(query, limit, allowedDomains, blockedDomains) {
   const results = [];
+  const warnings = [];
   try {
     const encodedQuery = encodeURIComponent(query);
-    const url = `https://api.github.com/search/issues?q=${encodedQuery}+is:issue&sort=reactions&order=desc&per_page=${limit}`;
-    const response = await httpGet(url);
+    const url = `https://api.github.com/search/issues?q=${encodedQuery}+is:issue&sort=reactions&order=desc&per_page=${limit * 2}`;
+    const domainCheck = passesDomainFilter(url, allowedDomains, blockedDomains);
+    if (!domainCheck.passes) {
+      warnings.push(`GitHub search skipped: ${domainCheck.reason}`);
+      return results;
+    }
+    const response = await httpGet(url, {
+      "Accept": "application/vnd.github+json"
+    });
     const data = JSON.parse(response);
     if (data.items) {
-      for (const item of data.items.slice(0, limit)) {
+      for (const item of data.items.slice(0, limit * 2)) {
+        if (results.length >= limit) break;
+        const urlCheck = passesDomainFilter(item.html_url, allowedDomains, blockedDomains);
+        if (!urlCheck.passes) {
+          continue;
+        }
         let content = `# ${item.title}
 
 `;
@@ -7130,18 +7255,32 @@ ${cleanContent(item.body, 2500)}
     }
   } catch (error) {
     console.error(`[search_web] GitHub error: ${error.message}`);
+    if (error.message.includes("403")) {
+      warnings.push("GitHub API rate limit may have been reached");
+    }
   }
   return results;
 }
-async function searchStackOverflow(query, limit) {
+async function searchStackOverflow(query, limit, allowedDomains, blockedDomains) {
   const results = [];
+  const warnings = [];
   try {
     const encodedQuery = encodeURIComponent(query);
-    const url = `https://api.stackexchange.com/2.3/search/advanced?order=desc&sort=relevance&q=${encodedQuery}&site=stackoverflow&pagesize=${limit}&filter=withbody`;
+    const url = `https://api.stackexchange.com/2.3/search/advanced?order=desc&sort=relevance&q=${encodedQuery}&site=stackoverflow&pagesize=${limit * 2}&filter=withbody`;
+    const domainCheck = passesDomainFilter(url, allowedDomains, blockedDomains);
+    if (!domainCheck.passes) {
+      warnings.push(`StackOverflow search skipped: ${domainCheck.reason}`);
+      return results;
+    }
     const response = await httpGet(url);
     const data = JSON.parse(response);
     if (data.items) {
-      for (const item of data.items.slice(0, limit)) {
+      for (const item of data.items.slice(0, limit * 2)) {
+        if (results.length >= limit) break;
+        const urlCheck = passesDomainFilter(item.link, allowedDomains, blockedDomains);
+        if (!urlCheck.passes) {
+          continue;
+        }
         let content = `# ${item.title}
 
 `;
@@ -7195,64 +7334,96 @@ ${cleanContent(cleanAnswer, 2e3)}
   }
   return results;
 }
-async function searchWeb(args) {
+async function searchX(query, limit, allowedDomains, blockedDomains) {
+  const results = [];
+  const warnings = [];
+  warnings.push("X (Twitter) search is not available - API requires authentication");
   try {
-    const {
-      query,
-      sources = DEFAULT_SOURCES,
-      max_results = MAX_RESULTS_DEFAULT
-    } = args;
-    if (!query || typeof query !== "string") {
-      return {
-        success: false,
-        query: query || "",
-        results: [],
-        sources_searched: [],
-        total_results: 0,
-        error: "query is required and must be a string"
-      };
+    const encodedQuery = encodeURIComponent(`${query} site:twitter.com OR site:x.com`);
+    const url = `https://www.google.com/search?q=${encodedQuery}&num=${limit}`;
+    const domainCheck = passesDomainFilter(url, allowedDomains, blockedDomains);
+    if (!domainCheck.passes) {
+      warnings.push(`X search skipped: ${domainCheck.reason}`);
+      return results;
     }
-    const allResults = [];
-    const sourcesSearched = [];
-    const resultsPerSource = Math.ceil(max_results / sources.length);
-    const searches = [];
-    for (const source of sources) {
-      sourcesSearched.push(source);
-      switch (source) {
-        case "reddit":
-          searches.push(searchReddit(query, resultsPerSource));
-          break;
-        case "github":
-          searches.push(searchGitHub(query, resultsPerSource));
-          break;
-        case "stackoverflow":
-          searches.push(searchStackOverflow(query, resultsPerSource));
-          break;
-      }
-    }
-    const searchResults = await Promise.all(searches);
-    for (const results of searchResults) {
-      allResults.push(...results);
-    }
-    allResults.sort((a, b) => (b.score || 0) - (a.score || 0));
-    const limitedResults = allResults.slice(0, max_results);
-    return {
-      success: true,
-      query,
-      results: limitedResults,
-      sources_searched: sourcesSearched,
-      total_results: limitedResults.length
-    };
   } catch (error) {
+    console.error(`[search_web] X error: ${error.message}`);
+  }
+  return results;
+}
+async function searchWeb(args) {
+  const startTime = performance.now();
+  const warnings = [];
+  let searchesPerformed = 0;
+  const validation = validateInput(args);
+  if (!validation.valid) {
     return {
       success: false,
       query: args.query || "",
       results: [],
       sources_searched: [],
       total_results: 0,
-      error: `Unexpected error: ${error.message}`
+      duration_seconds: 0,
+      searches_performed: 0,
+      error: validation.error
     };
   }
+  const {
+    query,
+    sources = DEFAULT_SOURCES,
+    max_results = MAX_RESULTS_DEFAULT,
+    allowed_domains,
+    blocked_domains,
+    max_uses = MAX_USES_DEFAULT
+  } = args;
+  if (sources.length > max_uses) {
+    warnings.push(`Requested ${sources.length} sources but max_uses is ${max_uses} - limiting to ${max_uses} sources`);
+  }
+  const allResults = [];
+  const sourcesSearched = [];
+  const limitedSources = sources.slice(0, max_uses);
+  const resultsPerSource = Math.ceil(max_results / limitedSources.length);
+  const searches = [];
+  for (const source of limitedSources) {
+    sourcesSearched.push(source);
+    switch (source) {
+      case "reddit":
+        searches.push(searchReddit(query, resultsPerSource, allowed_domains, blocked_domains));
+        break;
+      case "github":
+        searches.push(searchGitHub(query, resultsPerSource, allowed_domains, blocked_domains));
+        break;
+      case "stackoverflow":
+        searches.push(searchStackOverflow(query, resultsPerSource, allowed_domains, blocked_domains));
+        break;
+      case "x":
+        searches.push(searchX(query, resultsPerSource, allowed_domains, blocked_domains));
+        break;
+    }
+  }
+  const searchResults = await Promise.all(searches);
+  searchesPerformed = searchResults.length;
+  for (const results of searchResults) {
+    allResults.push(...results);
+  }
+  allResults.sort((a, b) => (b.score || 0) - (a.score || 0));
+  const limitedResults = allResults.slice(0, max_results);
+  const endTime = performance.now();
+  const durationSeconds = (endTime - startTime) / 1e3;
+  if (limitedResults.length === 0) {
+    warnings.push("No results found - try adjusting your query or domain filters");
+  }
+  return {
+    success: true,
+    query,
+    results: limitedResults,
+    sources_searched: sourcesSearched,
+    total_results: limitedResults.length,
+    duration_seconds: Math.round(durationSeconds * 100) / 100,
+    // 2 casas decimais
+    searches_performed: searchesPerformed,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
 }
 
 // src/app/agent/tools/natives/load_skill.ts
@@ -13036,7 +13207,7 @@ You are the **BluMa Coordinator** \u2014 a **Product Owner + Engineering Manager
 
 ## 0. Core Philosophy: Team > Solo
 
-**One AI is good. A coordinated team of 3-7 AIs is exponentially better.**
+**One AI is good. A coordinated team of 3-7 AIs can be better when the task truly benefits from delegation.**
 
 Think of yourself as a **rigorous PO** who:
 - Receives a request from the user (the "client")
@@ -13044,7 +13215,7 @@ Think of yourself as a **rigorous PO** who:
 - Assigns each task to the right specialist worker
 - Coordinates their work in parallel
 - Verifies quality before delivering to the client
-- **Always prefers team execution over solo work** for anything non-trivial
+- **Prefer team execution** when the task is non-trivial, parallelizable, risky, or needs independent verification
 
 **Why this matters:**
 - **Quality**: Each worker focuses deeply on one aspect \u2192 fewer mistakes
@@ -13054,14 +13225,15 @@ Think of yourself as a **rigorous PO** who:
 - **CEO appreciation**: Systematic, professional approach that scales
 
 **Default behavior**: When a task arrives, your first instinct should be:
-> "How can I break this into parallel worker tasks?"
+> "Can I answer or handle this directly?"
 
-Not: "How do I do this myself?"
+Only if the answer is no, ask:
+> "How can I break this into parallel worker tasks?"
 
 ## 1. Your Role
 
 You do **NOT execute tasks directly** (except trivial reads). Your job is to:
-- **Orchestrate workers** to research, implement, and verify changes
+- **Orchestrate workers** to research, implement, and verify changes when that materially improves speed, quality, or confidence
 - **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
@@ -14233,7 +14405,7 @@ Use **both** API **reasoning** (when available) **and** the \`message\` tool. Re
 - Never claim success without tool output that proves it.
 - **Stay audible:** Your **default** in multi-step work is to call \`message\` with \`message_type: "info"\` **early and often** \u2014 not optional polish. **Bias toward sending \`info\`** after discoveries, failures, and before long tool chains; **several \`info\` calls per turn** is normal and expected. Do **not** hide behind tools or reasoning only; \`info\` is how the user follows along.
 - **Ask when uncertain:** Use \`ask_user_question\` when you encounter ambiguity, need clarification, or face multiple valid approaches. Do not assume \u2014 ask the user to make decisions about their preferences, requirements, or implementation choices. This tool is your primary mechanism for resolving uncertainty.
-- **Team-first mindset:** For any non-trivial task, prefer spawning parallel workers over doing it yourself. One AI is good; a coordinated team of 3-7 workers is exponentially better. Break work into research \u2192 implementation \u2192 verification phases, each handled by specialist workers. You are the PO \u2014 orchestrate, synthesize, verify, deliver.
+- **Worker policy:** Use workers surgically, not by default. Do the work directly when the task is simple, local, or already well-scoped. Spawn workers when the task is genuinely non-trivial, parallelizable, risky, or needs independent verification. Break larger efforts into research \u2192 implementation \u2192 verification phases when that creates real value. You are the PO \u2014 orchestrate when it helps, synthesize, verify, deliver.
 - **Engineer mindset \u2014 question anomalies:** When something seems wrong (memory loss, unexpected behavior, aggressive defaults), **investigate deeply**. Do not accept "it's working as designed". Trace the code, find the root cause, and **have courage to revert** if a feature breaks core functionality. Protect the session, memory, and stability above all.
 - **Courage to reverse:** If you discover a path is wrong (e.g., a "feature" that destroys context, a default that's too aggressive), **stop immediately**, explain why it's broken, and revert/remove it. Better to undo a bad change than to let it cause harm. This is what separates a **thinking engineer** from a **blind executor**.
 - Large efforts: \`todo\`; parallel subtasks: \`spawn_agent\` with a clear scope + \`wait_agent\` / \`list_agents\`.
@@ -14654,6 +14826,29 @@ async function createApiContextWindow(fullHistory, currentAnchor, compressedTurn
 init_runtime_config();
 import os23 from "os";
 import OpenAI from "openai";
+
+// src/app/agent/core/llm/streaming_delta.ts
+function extractStreamingDelta(previous, next) {
+  const prev = String(previous ?? "");
+  const curr = String(next ?? "");
+  if (!curr) return "";
+  if (!prev) return curr;
+  if (curr.startsWith(prev)) {
+    return curr.slice(prev.length);
+  }
+  if (prev.startsWith(curr)) {
+    return "";
+  }
+  const maxOverlap = Math.min(prev.length, curr.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+    if (prev.slice(-overlap) === curr.slice(0, overlap)) {
+      return curr.slice(overlap);
+    }
+  }
+  return curr;
+}
+
+// src/app/agent/core/llm/llm.ts
 function defaultBlumaUserContextInput(sessionId, userMessage) {
   const msg = String(userMessage || "").slice(0, 300);
   return {
@@ -14845,12 +15040,17 @@ var LLMService = class {
       { headers: this.requestHeaders(params.userContext) }
     );
     const toolCallsAccumulator = /* @__PURE__ */ new Map();
+    let reasoningSnapshot = "";
     for await (const chunk of stream) {
       const choice = chunk.choices[0];
       if (!choice) continue;
       const delta = choice.delta;
       applyDeltaToolCallsToAccumulator(toolCallsAccumulator, delta?.tool_calls);
-      const reasoning = delta?.reasoning_content || delta?.reasoning || "";
+      const rawReasoning = delta?.reasoning_content || delta?.reasoning || "";
+      const reasoning = extractStreamingDelta(reasoningSnapshot, rawReasoning);
+      if (reasoning) {
+        reasoningSnapshot += reasoning;
+      }
       const fullToolCalls = choice.finish_reason === "tool_calls" ? Array.from(toolCallsAccumulator.values()) : void 0;
       yield {
         delta: delta?.content || "",
@@ -14873,6 +15073,32 @@ var LLMService = class {
   }
 };
 
+// src/app/agent/core/llm/llm_errors.ts
+function formatLlmUiError(error) {
+  const rawMessage = error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error during LLM request.";
+  const lower = rawMessage.toLowerCase();
+  let message2 = "Ocorreu um erro inesperado ao contactar o modelo.";
+  let hint = "Tente novamente. Se continuar, verifique a liga\xE7\xE3o ao FactorRouter.";
+  if (lower.includes("timeout") || lower.includes("etimedout") || lower.includes("upstream_timeout")) {
+    message2 = "O BluMa demorou demasiado a responder.";
+    hint = "Aumente o timeout do pedido ou tente novamente.";
+  } else if (lower.includes("connection") || lower.includes("econnrefused") || lower.includes("ehostunreach") || lower.includes("enotfound")) {
+    message2 = "N\xE3o foi poss\xEDvel conectar ao servi\xE7o do modelo.";
+    hint = "Verifique a rede, o FactorRouter_URL e o estado do gateway.";
+  } else if (lower.includes("401") || lower.includes("403") || lower.includes("unauthorized") || lower.includes("forbidden")) {
+    message2 = "Falha de autentica\xE7\xE3o/autoriza\xE7\xE3o ao contactar o modelo.";
+    hint = "Verifique o FactorRouter_KEY e as permiss\xF5es da conta.";
+  } else if (lower.includes("api")) {
+    message2 = "Erro de comunica\xE7\xE3o com a API do modelo.";
+    hint = "Verifique credenciais e o estado do servi\xE7o upstream.";
+  }
+  return {
+    message: message2,
+    details: rawMessage,
+    hint
+  };
+}
+
 // src/app/agent/core/llm/tool_call_normalizer.ts
 import { randomUUID } from "crypto";
 var ToolCallNormalizer = class {
@@ -15331,8 +15557,8 @@ var BluMaAgent = class {
   factorRouterTurnClosed = false;
   /** Passos seguidos sem tool_calls nem texto visível (só raciocínio) — evita loop lento no mesmo turno. */
   emptyAssistantReplySteps = 0;
-  /** Passos seguidos com texto do assistente sem tool_calls (violação de protocolo) — evita loop até timeout do job. */
-  directTextProtocolSteps = 0;
+  /** Deduplicação de reasoning chunks no streaming — evita repetição. */
+  lastReasoningChunkRef = "";
   constructor(sessionId, eventBus, llm, mcpClient, feedbackSystem) {
     this.sessionId = sessionId;
     this.eventBus = eventBus;
@@ -15483,7 +15709,6 @@ var BluMaAgent = class {
     const userContent = buildUserMessageContent(inputText, process.cwd());
     this.history.push({ role: "user", content: userContent });
     this.emptyAssistantReplySteps = 0;
-    this.directTextProtocolSteps = 0;
     this.eventBus.emit(
       "backend_message",
       buildTurnStartBackendMessage({
@@ -15529,15 +15754,18 @@ var BluMaAgent = class {
       }
     } catch (parseError) {
       this.eventBus.emit("backend_message", {
-        type: "error",
-        message: `Failed to parse tool arguments: ${parseError.message}`
+        type: "info",
+        message: "O BluMa encontrou um erro ao processar. A tentar recuperar a sess\xE3o..."
       });
       toolResultContent = JSON.stringify({
-        error: "Invalid tool arguments format",
-        details: `The arguments could not be parsed as JSON: ${parseError.message}`,
-        raw_arguments: toolCall.function.arguments
+        error: "Tool arguments could not be parsed",
+        recovery: "Session recovered automatically"
       });
       this.history.push({ role: "tool", tool_call_id: toolCall.id, content: toolResultContent });
+      this.history.push({
+        role: "system",
+        content: "The previous tool call had invalid JSON arguments. Please retry with properly formatted JSON arguments."
+      });
       this.persistSession();
       return true;
     }
@@ -15697,13 +15925,12 @@ var BluMaAgent = class {
         parsed.push({ toolCall, toolName: toolCall.function.name, toolArgs });
       } catch (parseError) {
         const toolResultContent = JSON.stringify({
-          error: "Invalid tool arguments format",
-          details: String(parseError?.message || parseError),
-          raw_arguments: toolCall.function.arguments
+          error: "Tool arguments could not be parsed",
+          recovery: "Session recovered automatically"
         });
         this.eventBus.emit("backend_message", {
-          type: "error",
-          message: `Failed to parse tool arguments: ${parseError.message}`
+          type: "info",
+          message: "O BluMa encontrou um erro ao processar. A tentar recuperar a sess\xE3o..."
         });
         this.history.push({ role: "tool", tool_call_id: toolCall.id, content: toolResultContent });
         this.persistSession();
@@ -15935,8 +16162,18 @@ ${editData.error.display}`;
         await this._handleNonStreamingResponse(contextWindow);
       }
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "An unknown API error occurred.";
-      this.eventBus.emit("backend_message", { type: "error", message: errorMessage });
+      const uiError = formatLlmUiError(error);
+      this.eventBus.emit("backend_message", {
+        type: "error",
+        message: uiError.message,
+        details: uiError.details,
+        hint: uiError.hint
+      });
+      this.eventBus.emit("backend_message", {
+        type: "log",
+        message: "LLM request failed",
+        payload: uiError.details
+      });
       await this.notifyFactorTurnEndIfNeeded("llm_error");
       this.eventBus.emit("backend_message", { type: "done", status: "failed" });
     } finally {
@@ -15956,13 +16193,12 @@ ${editData.error.display}`;
       });
     } else if (this.emptyAssistantReplySteps >= 6) {
       this.eventBus.emit("backend_message", {
-        type: "error",
-        message: "The assistant produced no tool calls or visible text after several steps. Try again or use /effort low."
+        type: "info",
+        message: "O BluMa est\xE1 a ter dificuldade em processar. Tente novamente ou use /effort low para respostas mais r\xE1pidas."
       });
       await this.notifyFactorTurnEndIfNeeded("empty_reply_exhausted");
       this.eventBus.emit("backend_message", { type: "done", status: "failed" });
       this.emptyAssistantReplySteps = 0;
-      this.directTextProtocolSteps = 0;
       return;
     }
     await this._continueConversation();
@@ -15994,6 +16230,7 @@ ${editData.error.display}`;
       parallel_tool_calls: true,
       userContext: this.getLlmUserContext()
     });
+    this.lastReasoningChunkRef = "";
     for await (const chunk of stream) {
       if (this.isInterrupted) {
         this.eventBus.emit("stream_end", {});
@@ -16005,7 +16242,11 @@ ${editData.error.display}`;
           this.eventBus.emit("stream_start", {});
           hasEmittedStart = true;
         }
-        this.eventBus.emit("stream_reasoning_chunk", { delta: chunk.reasoning });
+        const reasoningKey = chunk.reasoning.trim().replace(/\s+/g, " ");
+        if (reasoningKey !== this.lastReasoningChunkRef) {
+          this.lastReasoningChunkRef = reasoningKey;
+          this.eventBus.emit("stream_reasoning_chunk", { delta: chunk.reasoning });
+        }
       }
       if (chunk.delta) {
         if (!hasEmittedStart) {
@@ -16044,7 +16285,6 @@ ${editData.error.display}`;
     this.history.push(normalizedMessage);
     if (normalizedMessage.tool_calls && normalizedMessage.tool_calls.length > 0) {
       this.emptyAssistantReplySteps = 0;
-      this.directTextProtocolSteps = 0;
       const validToolCalls = normalizedMessage.tool_calls.filter(
         (call) => ToolCallNormalizer.isValidToolCall(call)
       );
@@ -16084,28 +16324,13 @@ ${editData.error.display}`;
       }
     } else if (trimmedText) {
       this.emptyAssistantReplySteps = 0;
-      this.directTextProtocolSteps += 1;
-      const MAX_DIRECT_TEXT_PROTOCOL = 3;
-      if (!hasEmittedStart) {
-        this.eventBus.emit("backend_message", { type: "assistant_message", content: accumulatedContent });
-      }
-      if (this.directTextProtocolSteps >= MAX_DIRECT_TEXT_PROTOCOL) {
-        this.eventBus.emit("backend_message", {
-          type: "error",
-          message: 'Agent kept answering with plain assistant text instead of the `message` tool with message_type "result". Turn forcibly closed to avoid job timeout; fix prompts or model routing.'
-        });
-        await this.notifyFactorTurnEndIfNeeded("protocol_direct_text_exhausted");
-        this.emitTurnCompleted();
-        this.emptyAssistantReplySteps = 0;
-        this.directTextProtocolSteps = 0;
-        return;
-      }
-      const feedback = this.feedbackSystem.generateFeedback({
-        event: "protocol_violation_direct_text",
-        details: { violationContent: accumulatedContent }
+      this.eventBus.emit("backend_message", { type: "assistant_message", content: accumulatedContent });
+      this.eventBus.emit("info", {
+        message: "Assistant returned plain text without tool_calls. Closing the turn to avoid protocol drift."
       });
-      this.history.push({ role: "system", content: feedback.correction });
-      await this._continueConversation();
+      await this.notifyFactorTurnEndIfNeeded("assistant_text_without_tool_call");
+      this.emitTurnCompleted();
+      return;
     } else {
       await this.continueAfterEmptyAssistantResponse();
     }
@@ -16135,7 +16360,6 @@ ${editData.error.display}`;
     this.history.push(message2);
     if (message2.tool_calls && message2.tool_calls.length > 0) {
       this.emptyAssistantReplySteps = 0;
-      this.directTextProtocolSteps = 0;
       const validToolCalls = message2.tool_calls.filter(
         (call) => ToolCallNormalizer.isValidToolCall(call)
       );
@@ -16175,27 +16399,13 @@ ${editData.error.display}`;
       }
     } else if (typeof message2.content === "string" && message2.content.trim()) {
       this.emptyAssistantReplySteps = 0;
-      this.directTextProtocolSteps += 1;
-      const MAX_DIRECT_TEXT_PROTOCOL = 3;
       this.eventBus.emit("backend_message", { type: "assistant_message", content: message2.content });
-      if (this.directTextProtocolSteps >= MAX_DIRECT_TEXT_PROTOCOL) {
-        this.eventBus.emit("backend_message", {
-          type: "error",
-          message: 'Agent kept answering with plain assistant text instead of the `message` tool with message_type "result". Turn forcibly closed to avoid job timeout.'
-        });
-        await this.notifyFactorTurnEndIfNeeded("protocol_direct_text_exhausted");
-        this.emitTurnCompleted();
-        this.emptyAssistantReplySteps = 0;
-        this.directTextProtocolSteps = 0;
-        return;
-      }
-      const feedback = this.feedbackSystem.generateFeedback({
-        event: "protocol_violation_direct_text",
-        details: { violationContent: message2.content }
+      this.eventBus.emit("info", {
+        message: "Assistant returned plain text without tool_calls. Closing the turn to avoid protocol drift."
       });
-      this.eventBus.emit("backend_message", { type: "protocol_violation", message: feedback.message, content: message2.content });
-      this.history.push({ role: "system", content: feedback.correction });
-      await this._continueConversation();
+      await this.notifyFactorTurnEndIfNeeded("assistant_text_without_tool_call");
+      this.emitTurnCompleted();
+      return;
     } else {
       await this.continueAfterEmptyAssistantResponse();
     }
@@ -16993,11 +17203,13 @@ var BaseLLMSubAgent = class {
   /** Um turnId por execute(); reutilizado em todo o loop de tools do subagente. */
   subagentTurnContext = null;
   lastActivityTimestamp = Date.now();
+  terminalEventEmitted = false;
   async execute(input, ctx) {
     workerLog.info("Worker started", { id: this.id, pid: process.pid });
     this.emitEvent("worker_heartbeat", { status: "started", timestamp: Date.now(), pid: process.pid, id: this.id });
     this.ctx = ctx;
     this.isInterrupted = false;
+    this.terminalEventEmitted = false;
     this.ctx.eventBus.on("user_interrupt", () => {
       this.isInterrupted = true;
     });
@@ -17060,13 +17272,15 @@ var BaseLLMSubAgent = class {
             this.emitEvent("error", {
               message: `Subagent tool "${message2.tool_calls[0].function.name}" requires confirmation outside sandbox mode.`
             });
-            this.emitEvent("done", { status: "blocked_confirmation" });
+            this.emitDoneOnce("blocked_confirmation");
             break;
           }
           await this._handleToolExecution({ type: "user_decision_execute", tool_calls: message2.tool_calls });
-        } else if (message2.content) {
+        } else if (typeof message2.content === "string" && message2.content.trim()) {
           this.emitEvent("assistant_message", { content: message2.content });
-          this.emitEvent("protocol_violation", { message: "Direct text emission detected from subagent.", content: message2.content });
+          this.emitEvent("info", { message: "SubAgent returned plain text without tool_calls. Closing turn." });
+          this.emitDoneOnce("completed");
+          break;
         } else {
           this.emitEvent("info", { message: "SubAgent is thinking... continuing reasoning cycle." });
         }
@@ -17074,8 +17288,9 @@ var BaseLLMSubAgent = class {
       }
       if (turnCount >= MAX_TURNS) {
         this.emitEvent("info", { message: `Worker reached max turns limit (${MAX_TURNS}).` });
-        this.emitEvent("done", { status: "max_turns_reached" });
+        this.emitDoneOnce("max_turns_reached");
       }
+      this.emitDoneOnce("completed");
       return { history: this.history, turns: turnCount, status: this.isInterrupted ? "cancelled" : "completed" };
     };
     const timeoutPromise = new Promise((_, reject) => {
@@ -17088,7 +17303,7 @@ var BaseLLMSubAgent = class {
       if (error.message?.includes("timed out")) {
         workerLog.warn("Worker timed out", { id: this.id, turns: turnCount });
         this.emitEvent("error", { message: error.message });
-        this.emitEvent("done", { status: "timeout" });
+        this.emitDoneOnce("timeout");
       } else {
         this.emitEvent("error", { message: error.message });
       }
@@ -17189,9 +17404,11 @@ ${editData.error.display}`;
         if (!lastToolName.includes("agent_end_turn") && !this.isInterrupted) {
           await this._continueConversation();
         }
-      } else if (message2.content) {
+      } else if (typeof message2.content === "string" && message2.content.trim()) {
         this.emitEvent("assistant_message", { content: message2.content });
-        this.emitEvent("protocol_violation", { message: "Direct text emission detected from subagent.", content: message2.content });
+        this.emitEvent("info", { message: "SubAgent returned plain text without tool_calls. Closing turn." });
+        this.emitEvent("done", { status: "completed" });
+        return;
       } else {
         this.emitEvent("info", { message: "SubAgent is thinking... continuing reasoning cycle." });
       }
@@ -17247,7 +17464,7 @@ ${editData.error.display}`;
         result: toolResultContent
       });
       if (toolName.includes("agent_end_turn")) {
-        this.emitEvent("done", { status: "completed" });
+        this.emitDoneOnce("completed");
       }
     } else {
       toolResultContent = "Tool execution was declined.";
@@ -17286,7 +17503,12 @@ ${editData.error.display}`;
     } catch {
     }
     this.isInterrupted = true;
-    this.emitEvent("done", { status: "shutdown", reason });
+    this.emitDoneOnce("shutdown", { reason });
+  }
+  emitDoneOnce(status, extra = {}) {
+    if (this.terminalEventEmitted) return;
+    this.terminalEventEmitted = true;
+    this.emitEvent("done", { status, ...extra });
   }
   /**
    * Verifica mailbox por follow-ups do coordinator

package/package.json

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