nyxora 26.7.8 → 26.7.10

package/CHANGELOG.md

@@ -4,6 +4,49 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepashangelog.com/en/1.0.0/),
 
+## [26.7.10]
+### Web3 Integrations
+- **Robinhood Chain Support**: Officially integrated `Robinhood Chain` (Mainnet) and `Robinhood Testnet` support natively via `viem` `v2.55.0` upgrade. Added seamless RPC mappings, updated the dashboard network selectors with official SVG branding, and ensured high-frequency trading capabilities in the Signer remain stable.
+
+### Core Architecture & Routing
+- **Deterministic Intent Fast-Path**: Bypassed the LLM semantic router for short confirmation phrases. Messages containing global confirmation keywords (e.g., "yes", "sure", "proceed") now deterministically inherit the strict contextual boundary (`os` or `web3`) of the Assistant's previous permission request, completely eradicating routing hallucinations.
+- **Global Codebase Standardization**: Refactored hardcoded regional slang from the routing logic into a comprehensive, professional English-first `CONFIRM_WORDS` array, natively supporting global users while retaining common localized confirmations as secondary fallbacks.
+
+### Fallback Execution Engine
+- **Native `<execute_bash>` Support**: Enhanced the `osAgent` and `web3Agent` Fallback Parsers to autonomously intercept and parse `<execute_bash>` and `<execute>` XML tags. This restores full execution capability for open-weight models that instinctively utilize these tags instead of strict JSON tool calls.
+- **Display Sanitization Hardening**: Appended `execute_bash` and `execute` to the automated UI Sanitizer `tagsToRemove` registry. Raw bash execution blocks hallucinated by the LLM are now stripped at the edge layer before streaming to Telegram or the Dashboard.
+
+### Web3 Signer SDK & Execution Guardrails
+- **Receipt Waiter Integration (Anti-False-Positive)**: Remediated a severe "Fire-and-Forget" architectural bug in `NyxoraSigner.ts` where broadcasted transactions were immediately reported as successful to the LLM regardless of actual on-chain finality. The Signer now strictly executes a `waitForTransactionReceipt` hook (capped at a 20-second timeout). 
+- **Revert Detection**: If a transaction reverts on-chain (e.g., due to strict MEV slippage or gas exhaustion), the Signer violently rejects the promise with `reverted`, preventing the AI from falsely declaring success.
+- **Pending Timeout Grace**: If the blockchain experiences congestion and fails to confirm within the 20-second window, the system falls back gracefully by returning `"Transaction broadcasted (Pending receipt)"` to ensure the 30-second Policy Engine HTTP timeout is never triggered, allowing the AI to report accurate pending status.
+
+## [26.7.9]
+### Features & Architecture
+
+- **Deep Market Analysis Upgrade**: Significantly enhanced the Python ML Engine (`market.py`) to compute a comprehensive suite of advanced technical indicators including MACD, Bollinger Bands, EMA-20, ATR-14, and OBV using live OHLCV data.
+- **Smart Trend Classification**: The ML Engine now runs deterministic trend scoring (`STRONG_BULLISH` to `STRONG_BEARISH`) and generates an AI narrative summary of the market structure to prevent LLM hallucination and provide highly accurate context.
+- **Anti-Blocker Data Pipeline**: Bypassed Indonesian ISP blocks (e.g., internetsehat/ICON+) that previously blocked major crypto exchange APIs (Binance, Bybit, KuCoin, OKX) by routing historical candle data through `data-api.binance.vision`.
+
+### Refactor — Dependency & NPM Warning Cleanup
+
+- **Removed Unused & Problematic Dependencies**: Completely uninstalled `@google/genai`, `baileys`, and `@matrix-org/matrix-sdk-crypto-nodejs` from the workspace. This fully eliminates the annoying `npm warn allow-scripts` warnings that users previously encountered when running `npm install -g nyxora` or standard `npm install`.
+- **Migrated Image Analysis SDK**: Refactored `analyzeImage.ts` (Dynamic Require) to use `@google/generative-ai` (which has no install scripts) instead of the newer `@google/genai` (which triggers NPM security warnings), maintaining full Gemini 2.5 Flash compatibility.
+
+### Bug Fix — Playbooks Missing for Global npm Users
+
+- **Playbooks Not Distributed to Global Users (Critical Fix)**: Resolved a packaging omission where `packages/core/playbooks/` (containing 70 bundled SKILL.md playbooks) was missing from the `files[]` array in `package.json`. Global users running `npm install -g nyxora` never received any playbooks, causing `search_playbook` to always return "No playbooks available." and the system prompt to never list available skills. Fixed by adding `"packages/core/playbooks"` to the `files[]` field.
+
+### Bug Fix — "No response generated." Crash on Complex Multi-Step Prompts
+
+- **ContextSummarizer Redundant 4x LLM Calls (Critical Fix)**: Fixed a severe loop bug where `compressHistory()` was called once per nudge iteration (up to 4x per request) instead of once per session turn. The compressed result was never persisted back to the logger, so every iteration re-fetched the full uncompressed history and triggered another full LLM summarization call. Added a per-session in-memory cache keyed by text message count: if no new user/assistant messages have arrived, the cached compressed result is reused immediately — eliminating the redundant LLM calls entirely.
+- **TaskPlanner Context Bloat**: Refactored the TaskPlanner to inject its execution plan as a `role: 'system'` logger entry instead of prepending it to the user input string. Previously, the plan was concatenated into the user message body (`planInjection + "\n\nUSER REQUEST: " + input`), which inflated the user message size stored in logger and compounded context bloat on every subsequent turn. Also capped generated plans at 120 words to prevent runaway context consumption.
+- **Nudge Messages Now Actionable**: Replaced the generic `"[SYSTEM NUDGE] You did not output any tool calls..."` message with a structured, actionable prompt that includes: the original user task (truncated to 200 chars), the list of relevant available tools, and explicit instruction to either call a tool or output a final text answer. Applies to both OS Agent and Web3 Agent.
+- **Dead-End Fallback Replaced**: Replaced `"No response generated."` (which leaves the user with no actionable path) with `"⚠️ I encountered an issue processing your request. This can happen with very complex multi-step tasks. Please try rephrasing or breaking the request into smaller steps."` in all 4 abort paths across `osAgent.ts` and `web3Agent.ts`.
+- **Thinking-Prefill Continuation (Critical Fix)**: Ported the core silent-stop recovery technique used by the Hermes agent framework. When a reasoning model (e.g. Gemini 2.5 Pro with `reasoning_effort: high`) produces internal thinking content but no visible text or tool calls, Nyxora now appends the assistant's reasoning turn as-is and continues the loop — allowing the model to see its own reasoning on the next turn and naturally produce a tool call or text response. This is a fundamentally different approach from system nudges (which restart the reasoning chain from scratch). Prefill is attempted up to 2 times before falling back to the nudge path. Applies to both OS Agent and Web3 Agent.
+- **Anti-Silent-Stop System Prompt Rule**: Added `CRITICAL RULE 6` to the OS agent system prompt explicitly forbidding silent stops: after reasoning is complete, the model MUST produce either tool calls or a visible text answer. Ending a turn with only internal thinking is explicitly stated as not acceptable.
+- **MAX_TURNS Raised (OS Agent)**: Increased the stream loop iteration cap from 10 to 15 to give complex multi-step tasks (e.g. write file → send to Telegram) sufficient room to complete without hitting the ceiling.
+
 ## [26.7.8]
 ### Bug Fixes — Global Compatibility & Dashboard Crash
 

package/README.md

@@ -2,14 +2,15 @@
 **Your Personal Web3 Assistant.**
 
 
-[![Status: Prototype](https://img.shields.io/badge/Status-Prototype-orange.svg)](#)
-
-[![MCP Supported](https://img.shields.io/badge/MCP-Supported-blue.svg)](#)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Security: Defense-in-Depth](https://img.shields.io/badge/Security-Defense--in--Depth-blue.svg)](#️-advanced-security-threat-model)
-[![Execution: Cryptographic Approval](https://img.shields.io/badge/Execution-Cryptographic--Approval-orange.svg)](#️-advanced-security-threat-model)
-[![Privacy: Local-Only Keys](https://img.shields.io/badge/Privacy-Local--Only--Keys-success.svg)](#️-advanced-security-threat-model)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://makeapullrequest.com)
+[![Status: Alpha](https://img.shields.io/badge/Status-Alpha-orange.svg?style=for-the-badge)](#)
+[![Donate on DeBank](https://img.shields.io/badge/DONATE-DEBANK-FE7E41?style=for-the-badge&logo=ethereum&logoColor=white)](https://debank.com/profile/0xe5c21f46993c67cfe04fcf1579486d390be7b535)
+
+[![MCP Supported](https://img.shields.io/badge/MCP-Supported-blue.svg?style=for-the-badge)](#)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
+[![Security: Defense-in-Depth](https://img.shields.io/badge/Security-Defense--in--Depth-blue.svg?style=for-the-badge)](#️-advanced-security-threat-model)
+[![Execution: Cryptographic Approval](https://img.shields.io/badge/Execution-Cryptographic--Approval-orange.svg?style=for-the-badge)](#️-advanced-security-threat-model)
+[![Privacy: Local-Only Keys](https://img.shields.io/badge/Privacy-Local--Only--Keys-success.svg?style=for-the-badge)](#️-advanced-security-threat-model)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge)](https://makeapullrequest.com)
 
 Nyxora is a **secure, non-custodial runtime infrastructure for autonomous onchain agents** built with a robust Monorepo architecture (Node.js & React). Designed for autonomous workflows with a premium Utility-Centric dark-themed UI and strict client-side key isolation. 
 

package/SUPPORT.md

@@ -0,0 +1,18 @@
+# Support Nyxora Protocol
+
+Nyxora is an open-source initiative built on the belief that powerful, zero-trust Web3 AI infrastructure should be accessible to everyone. We dedicate countless hours to research, continuous development, and maintaining this ecosystem to ensure it remains secure and cutting-edge.
+
+If Nyxora has brought value to you, your projects, or your organization, consider supporting our ongoing development. While completely optional, your contribution plays a vital role in helping us cover infrastructure costs, fund security audits, and dedicate more time to shipping new features.
+
+### How to Contribute
+
+We gratefully accept community support via any EVM-compatible network (Ethereum, Arbitrum, Optimism, Polygon, Binance Smart Chain, etc.).
+
+**EVM Address:**
+`0xE5c21F46993C67CFe04FCF1579486D390Be7B535`
+
+> 🔗 **[View & Donate via DeBank](https://debank.com/profile/0xe5c21f46993c67cfe04fcf1579486d390be7b535)**
+
+*Every contribution, no matter the size, is deeply appreciated and directly fuels the future of autonomous Web3 AI.*
+
+Thank you for being an amazing part of the Nyxora journey! 🌌

package/dist/packages/core/src/agent/osAgent.js

@@ -19,8 +19,8 @@ const picocolors_1 = __importDefault(require("picocolors"));
 registry_1.pluginManager.registerHook({
     name: 'ReasoningGate',
     beforeToolCall: async (toolName, args, context) => {
-        // FIX: Use actual Nyxora tool names (not legacy names)
-        const toolsRequiringReasoning = ['run_terminal_command', 'write_local_file', 'edit_local_file', 'execute_script'];
+        // FIX: Use actual Nyxora tool names (not legacy names). Removed run_terminal_command to prevent infinite loops.
+        const toolsRequiringReasoning = ['write_local_file', 'edit_local_file', 'execute_script'];
         if (toolsRequiringReasoning.includes(toolName)) {
             const responseMessage = context.responseMessage || {};
             const hasThinkingTag = /<(think|thought|thinking|reasoning|analysis|reflection)>[\s\S]*?<\/\1>/i.test(responseMessage.content || '');
@@ -37,8 +37,8 @@ registry_1.pluginManager.registerHook({
     name: 'Web3FastReturn',
     afterToolCall: async (toolName, args, result, context) => {
         // FIX: Only financial Web3 transactions need fast-return (to show approval popup ASAP).
-        // send_telegram_file is NOT a financial transaction — removed from this list.
-        const fastReturnTools = ['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3'];
+        // FIX: Re-added send_telegram_file so the agent stops "typing" after file is successfully uploaded.
+        const fastReturnTools = ['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3', 'send_telegram_file'];
         if (fastReturnTools.includes(toolName)) {
             return { terminate: true };
         }
@@ -142,7 +142,7 @@ CRITICAL INSTRUCTIONS:
             const currentHistory = exports.logger.getHistory(sessionId);
             // P6: Compress history if conversation is too long
             const historyToUse = (0, contextSummarizer_1.needsCompression)(currentHistory)
-                ? await (0, contextSummarizer_1.compressHistory)(currentHistory)
+                ? await (0, contextSummarizer_1.compressHistory)(currentHistory, sessionId)
                 : currentHistory;
             const sanitizedHistory = sanitizeHistoryForLLM(historyToUse, activeTools, config.llm.provider);
             // P1: Inject scratchpad into system prompt for turns > 1
@@ -171,27 +171,146 @@ CRITICAL INSTRUCTIONS:
             }
             tracker_1.Tracker.addEvent('llm.response', { provider: config.llm.provider, tool_calls: responseMessage.tool_calls?.length || 0 });
             // P1: Capture <think> blocks for scratchpad, get clean content
-            const cleanedContent = scratchpad.capture(responseMessage.content || '', turnCount);
+            let cleanedContent = scratchpad.capture(responseMessage.content || '', turnCount);
             exports.logger.addEntry({
                 role: 'assistant',
                 content: cleanedContent || '',
                 tool_calls: responseMessage.tool_calls,
             }, sessionId);
+            // --- LLM FALLBACK COMMAND PARSER (Minimax/Open-weight fix) ---
+            if ((!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) && responseMessage.content) {
+                const fallbacks = [];
+                // 1. Slash commands (/swap amount="100")
+                const regex = /^\/([a-zA-Z0-9_]+)\s+(.*)$/gm;
+                let match;
+                while ((match = regex.exec(responseMessage.content)) !== null) {
+                    const toolName = match[1];
+                    let argsStr = match[2];
+                    const argsObj = {};
+                    const kvRegex = /([a-zA-Z0-9_]+)=(".*?"|'.*?'|[^\s]+)/g;
+                    let kvMatch;
+                    while ((kvMatch = kvRegex.exec(argsStr)) !== null) {
+                        let key = kvMatch[1];
+                        let val = kvMatch[2].replace(/^["']|["']$/g, '');
+                        argsObj[key] = val;
+                    }
+                    // Map generic names if needed
+                    let mappedToolName = toolName;
+                    if (toolName === 'transfer' && argsObj.mode === 'bridge')
+                        mappedToolName = 'bridge_token';
+                    if (toolName === 'swap')
+                        mappedToolName = 'swap_token';
+                    fallbacks.push({
+                        id: 'call_fallback_' + Math.random().toString(36).substr(2, 9),
+                        type: 'function',
+                        function: {
+                            name: mappedToolName,
+                            arguments: JSON.stringify(argsObj)
+                        }
+                    });
+                }
+                // 2. Markdown bash blocks (```bash ... ```)
+                const mdRegex = /```(?:bash|sh|zsh)?\n([\s\S]*?)```/g;
+                let mdMatch;
+                while ((mdMatch = mdRegex.exec(responseMessage.content)) !== null) {
+                    const bashCmd = mdMatch[1].trim();
+                    if (bashCmd) {
+                        fallbacks.push({
+                            id: 'call_fallback_' + Math.random().toString(36).substr(2, 9),
+                            type: 'function',
+                            function: {
+                                name: 'run_terminal_command',
+                                arguments: JSON.stringify({ command: bashCmd })
+                            }
+                        });
+                    }
+                }
+                // 3. <tool_code> JSON arrays
+                const toolCodeRegex = /<tool_code>([\s\S]*?)<\/tool_code>/g;
+                let toolCodeMatch;
+                while ((toolCodeMatch = toolCodeRegex.exec(responseMessage.content)) !== null) {
+                    try {
+                        const jsonStr = toolCodeMatch[1].trim();
+                        const parsedArray = JSON.parse(jsonStr);
+                        if (Array.isArray(parsedArray)) {
+                            for (const item of parsedArray) {
+                                if (item.function_name && item.tool_args) {
+                                    fallbacks.push({
+                                        id: 'call_fallback_' + Math.random().toString(36).substr(2, 9),
+                                        type: 'function',
+                                        function: {
+                                            name: item.function_name,
+                                            arguments: typeof item.tool_args === 'string' ? item.tool_args : JSON.stringify(item.tool_args)
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Ignore parse errors, maybe it's not JSON
+                    }
+                }
+                // 4. <execute_bash> or <execute> blocks
+                const executeRegex = /<(?:execute_bash|execute)>([\s\S]*?)<\/(?:execute_bash|execute)>/g;
+                let executeMatch;
+                while ((executeMatch = executeRegex.exec(responseMessage.content)) !== null) {
+                    const bashCmd = executeMatch[1].trim();
+                    if (bashCmd) {
+                        fallbacks.push({
+                            id: 'call_fallback_' + Math.random().toString(36).substr(2, 9),
+                            type: 'function',
+                            function: {
+                                name: 'run_terminal_command',
+                                arguments: JSON.stringify({ command: bashCmd })
+                            }
+                        });
+                    }
+                }
+                if (fallbacks.length > 0) {
+                    responseMessage.tool_calls = fallbacks;
+                    responseMessage.content = responseMessage.content.replace(/^\/[a-zA-Z0-9_]+\s+.*$/gm, '').replace(/```(?:bash|sh|zsh)?\n([\s\S]*?)```/g, '').replace(/<tool_code>([\s\S]*?)<\/tool_code>/g, '').replace(/<(?:execute_bash|execute)>([\s\S]*?)<\/(?:execute_bash|execute)>/g, '').trim();
+                    console.log(picocolors_1.default.cyan(`[Fallback Parser] Intercepted ${fallbacks.length} raw text commands and converted to tool_calls.`));
+                    // Update logger entry with the intercepted tool calls
+                    exports.logger.addEntry({
+                        role: 'assistant',
+                        content: responseMessage.content || "",
+                        tool_calls: responseMessage.tool_calls,
+                    }, sessionId);
+                }
+            }
+            // -----------------------------------------------------
+            // --- DISPLAY SANITIZATION ---
+            // Remove commonly leaked XML tags (reasoning & tool calls) to prevent UI clutter
+            if (responseMessage.content) {
+                const tagsToRemove = ['tool_code', 'tool_call', 'tool_calls', 'function_call', 'function_calls', 'execute', 'execute_bash', 'think', 'thought', 'reasoning'];
+                tagsToRemove.forEach(tag => {
+                    // Remove complete tags and their contents
+                    const regex = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>\\s*`, 'gi');
+                    responseMessage.content = responseMessage.content.replace(regex, '');
+                    // Remove any orphaned closing tags
+                    const orphanRegex = new RegExp(`<\\/${tag}>\\s*`, 'gi');
+                    responseMessage.content = responseMessage.content.replace(orphanRegex, '');
+                });
+                responseMessage.content = responseMessage.content.trim();
+                cleanedContent = responseMessage.content;
+            }
+            // -----------------------------------------------------
             if (!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) {
                 // --- CRITIC PASS REMOVED ---
                 // The new PromptBuilder handles robust reasoning. Post-generation critic
                 // causes aggressive loops and UI artifacts.
                 triggerBackgroundReview(sessionId);
-                return cleanedContent || 'No response generated.';
+                return cleanedContent || '⚠️ I encountered an issue processing your request. This can happen with very complex multi-step tasks. Please try rephrasing or breaking the request into smaller steps.';
             }
             let canFastReturnAll = true;
             let accumulatedResults = [];
             // Enabled fastReturnTools to eliminate 2nd LLM latency for transaction popups
-            // FIX: Removed send_telegram_file — not a financial transaction
+            // FIX: Re-added send_telegram_file to prevent "typing" loop after file upload.
             const fastReturnTools = [
                 'transfer_token', 'transfer_native', 'swap_token', 'bridge_token',
                 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave',
-                'deposit_yield_vault', 'provide_liquidity_v3'
+                'deposit_yield_vault', 'provide_liquidity_v3', 'send_telegram_file'
             ];
             for (const _toolCall of responseMessage.tool_calls) {
                 const toolCall = _toolCall;
@@ -307,7 +426,7 @@ CRITICAL INSTRUCTIONS:
             // V2 Optimization: Zero-LLM Fast Return for transaction tools
             if (canFastReturnAll && accumulatedResults.length > 0) {
                 const finalContent = accumulatedResults.join('\n\n---\n\n');
-                exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
+                exports.logger.addEntry({ role: 'user', content: `[System Notification: The tool executed successfully and returned the following result directly to the user]\n${finalContent}` }, sessionId);
                 triggerBackgroundReview(sessionId);
                 return finalContent;
             }
@@ -373,13 +492,18 @@ CRITICAL INSTRUCTIONS:
     const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
     try {
         let turnCount = 0;
-        const MAX_TURNS = 10;
+        let nudgeCount = 0;
+        const MAX_TURNS = 15; // Increased from 10 — complex tasks need more turns
+        let thinkingPrefillRetries = 0; // Prefill-continuation retries for think-only silent stops
         let fullResponse = '';
         let criticHasFiredStream = false; // Critic Pass hanya aktif 1x per request
         while (turnCount < MAX_TURNS) {
             turnCount++;
             const currentHistory = exports.logger.getHistory(sessionId);
-            const sanitizedHistory = sanitizeHistoryForLLM(currentHistory, activeTools, config.llm.provider);
+            const historyToUse = (0, contextSummarizer_1.needsCompression)(currentHistory)
+                ? await (0, contextSummarizer_1.compressHistory)(currentHistory, sessionId)
+                : currentHistory;
+            const sanitizedHistory = sanitizeHistoryForLLM(historyToUse, activeTools, config.llm.provider);
             // FIX: Use cached system prompt — no longer rebuilt every turn
             const messages = [
                 { role: 'system', content: cachedSystemPromptStream },
@@ -388,11 +512,9 @@ CRITICAL INSTRUCTIONS:
             let streamedContent = '';
             const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
                 streamedContent = '';
-                // RC#1 FIX: Only clear the Telegram buffer on the FIRST turn.
-                // On subsequent turns (after tool calls), the buffer already shows useful
-                // progress info. Resetting it causes visible content to disappear.
-                if (turnCount === 1)
-                    onChunk('[CLEAR_STREAM]');
+                // RC#1 FIX: Always clear the buffer at the start of the stream turn.
+                // This ensures the client UI doesn't append duplicate preambles across multi-turn executions.
+                onChunk('[CLEAR_STREAM]');
                 return await client.stream({ model: config.llm.model, temperature: config.llm.temperature, messages, tools: activeTools, reasoning_effort: (!config.llm.reasoning_effort || config.llm.reasoning_effort === 'none') ? undefined : config.llm.reasoning_effort }, (chunk) => {
                     streamedContent += chunk;
                     onChunk(chunk);
@@ -411,11 +533,82 @@ CRITICAL INSTRUCTIONS:
                 tool_calls: responseMessage.tool_calls,
             }, sessionId);
             if (!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) {
-                let finalContent = responseMessage.content || 'No response generated.';
+                let finalContent = responseMessage.content || '';
                 finalContent = finalContent.replace(/<(think|thought|thinking|reasoning|analysis|reflection)[\s\S]*?<\/\1>\n?/gi, '').trim();
                 finalContent = finalContent.replace(/^\s*(?:\*\*)?(?:think|thought|thinking|reasoning|analysis|reflection)(?:\*\*)?\s*?\n[\s\S]*?\n\n/i, '').trim();
-                // --- CRITIC PASS REMOVED ---
-                // Prevents leaking internal reasoning into the stream and confusing the user.
+                // Support global languages: English, Indonesian, Spanish, French, German filler words
+                const isConversationalFiller = finalContent.length > 0 && finalContent.length < 250 && /(wait|checking|executing|processing|give me a moment|let me check|one moment|hold on|tunggu|sebentar|lagi proses|lanjut cek|gue cek|aku cek|un momento|attendez|bitte warten)[\s\.\!a-z]*$/i.test(finalContent.trim());
+                if (finalContent === '' || isConversationalFiller) {
+                    // Detect think-only response: model reasoned but produced no tool calls or visible text.
+                    const hasNativeReasoning = !!responseMessage.reasoning_content;
+                    const hasThinkTagInStream = /<(think|thought|thinking|reasoning)[\s\S]*?<\//i.test(streamedContent);
+                    const isThinkOnlyResponse = hasNativeReasoning || hasThinkTagInStream;
+                    // ── THINKING-PREFILL CONTINUATION ──
+                    // If model produced reasoning but no visible output, append the assistant message as-is
+                    // so the model sees its own reasoning on the next turn and continues naturally.
+                    // This avoids restarting the reasoning chain from scratch (which is what nudges do).
+                    if (isThinkOnlyResponse && thinkingPrefillRetries < 2) {
+                        thinkingPrefillRetries++;
+                        console.warn(`[OsAgentStream] ⚠️ Think-only silent stop — prefilling to continue (${thinkingPrefillRetries}/2)...`);
+                        // The assistant message is already in logger from the addEntry above.
+                        // The model will see its own reasoning and produce a tool call or text next turn.
+                        continue;
+                    }
+                    // ── NUDGE FALLBACK (after prefill exhaustion or truly empty) ──
+                    if (nudgeCount < 3) {
+                        nudgeCount++;
+                        const recentUserMsg = exports.logger.getHistory(sessionId)
+                            .filter((m) => m.role === 'user').slice(-1)[0]?.content || 'the user request';
+                        let nudgeContent;
+                        if (isThinkOnlyResponse) {
+                            console.warn(`[OsAgentStream] ⚠️ Think-only prefill exhausted. System nudge (${nudgeCount}/3)...`);
+                            nudgeContent = `[SYSTEM NUDGE ${nudgeCount}/3 — SILENT STOP DETECTED]
+You completed your internal reasoning but produced NO output (no tool call, no text).
+This is a silent stop — it is not acceptable.
+
+Task: "${recentUserMsg.substring(0, 200)}"
+
+You MUST act RIGHT NOW. Do one of these:
+  A) Call the first required tool immediately (e.g., write_local_file, run_terminal_command, send_telegram_file)
+  B) Output a final text answer
+
+Do NOT think again. Execute step 1 of the task NOW.`;
+                        }
+                        else {
+                            console.warn(`[OsAgentStream] ⚠️ Empty or filler response. System nudge (${nudgeCount}/3)...`);
+                            nudgeContent = `[SYSTEM NUDGE ${nudgeCount}/3] Your last response was empty or contained conversational filler without tool calls. You MUST take action now.
+
+Task: "${recentUserMsg.substring(0, 200)}"
+
+Available tools: write_local_file, run_terminal_command, send_telegram_file, search_web and others.
+You MUST either:
+  A) Call one or more tools, OR
+  B) Output a complete final text answer
+
+Do NOT output filler text like "Wait, I will check". Act now.`;
+                        }
+                        exports.logger.addEntry({
+                            role: 'system',
+                            content: nudgeContent
+                        }, sessionId);
+                        continue;
+                    }
+                    else {
+                        console.error('[OsAgentStream] ❌ LLM failed to recover after prefill + 3 nudges. Aborting.');
+                        // Last-resort recovery: surface reasoning_content if available
+                        const reasoningContent = responseMessage.reasoning_content || '';
+                        if (reasoningContent && reasoningContent.length > 50) {
+                            console.warn('[OsAgentStream] Using reasoning_content as fallback response.');
+                            finalContent = reasoningContent.replace(/<(think|thought|thinking)[\s\S]*?<\/\1>/gi, '').trim()
+                                || '⚠️ I encountered an issue processing your request. This can happen with very complex multi-step tasks. Please try rephrasing or breaking the request into smaller steps.';
+                        }
+                        else {
+                            finalContent = '⚠️ I encountered an issue processing your request. This can happen with very complex multi-step tasks. Please try rephrasing or breaking the request into smaller steps.';
+                        }
+                    }
+                }
+                // Reset prefill counter on successful response
+                thinkingPrefillRetries = 0;
                 fullResponse = finalContent;
                 triggerBackgroundReview(sessionId);
                 break;
@@ -425,10 +618,20 @@ CRITICAL INSTRUCTIONS:
             // LLM often generates "thinking out loud" text before calling a tool (e.g. "Let me check...").
             // This text should NOT be shown to users. [TOOL_CALL_DETECTED] resets the buffer to a
             // clean progress indicator, hiding the planning text without losing the message handle.
-            onChunk('[TOOL_CALL_DETECTED]');
+            await onChunk('[TOOL_CALL_DETECTED]');
             let shouldFastReturn = false;
             const accumulatedResults = [];
-            const promises = responseMessage.tool_calls.map(async (_toolCall) => {
+            // Deduplicate identical tool calls to prevent double execution bugs
+            const uniqueToolCalls = [];
+            const seenToolCalls = new Set();
+            for (const tc of responseMessage.tool_calls) {
+                const sig = `${tc.function.name}:${tc.function.arguments}`;
+                if (!seenToolCalls.has(sig)) {
+                    seenToolCalls.add(sig);
+                    uniqueToolCalls.push(tc);
+                }
+            }
+            const promises = uniqueToolCalls.map(async (_toolCall) => {
                 const toolCall = _toolCall;
                 const toolName = toolCall.function.name;
                 let result = '';
@@ -436,7 +639,7 @@ CRITICAL INSTRUCTIONS:
                 const context = { sessionId, toolCallId: toolCall.id, responseMessage };
                 console.log(picocolors_1.default.yellow(`[⚡ Tool Execution] AI is calling ${toolName}...`));
                 if (onProgress)
-                    onProgress(`_⚡ Running tool: ${toolName}..._`);
+                    onProgress(`⚡ Running tool: ${toolName}...`);
                 try {
                     let argStr = toolCall.function.arguments;
                     if (argStr && !argStr.trim().endsWith('}'))
@@ -464,7 +667,7 @@ CRITICAL INSTRUCTIONS:
                     const pluginResult = await registry_1.pluginManager.executeTool(toolName, args, context, (partialResult) => {
                         // Partial Streaming callback
                         if (onProgress)
-                            onProgress(`_⏳ [${toolName}] ${partialResult}..._`);
+                            onProgress(`⏳ [${toolName}] ${partialResult}...`);
                     });
                     result = pluginResult !== null ? pluginResult : `Error: Tool ${toolName} is not implemented.`;
                     if (typeof result === 'string' && (result.includes('[Security Blocked]') || result.startsWith('Error:'))) {
@@ -489,11 +692,15 @@ CRITICAL INSTRUCTIONS:
             });
             const results = await Promise.all(promises);
             results.forEach(r => accumulatedResults.push(r.result));
+            await onChunk('[TOOL_CALL_FINISHED]');
             if (shouldFastReturn && accumulatedResults.length > 0) {
                 const finalContent = accumulatedResults.join('\n\n---\n\n');
-                exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
-                onChunk(finalContent);
-                fullResponse = finalContent;
+                const cleanContent = finalContent.replace(/\[SILENT_FAST_RETURN\] /g, '');
+                exports.logger.addEntry({ role: 'assistant', content: cleanContent }, sessionId);
+                if (!finalContent.includes('[SILENT_FAST_RETURN]')) {
+                    await onChunk(finalContent);
+                }
+                fullResponse = cleanContent;
                 triggerBackgroundReview(sessionId);
                 break;
             }

package/dist/packages/core/src/agent/promptBuilder.js

@@ -86,7 +86,9 @@ This tool runs in a NON-INTERACTIVE shell (no TTY). Therefore:
 - If a command fails with "sudo: a password is required" or similar, DO NOT promise to retry without actually retrying.
 - Instead, try running the command WITHOUT sudo if possible (e.g. for user-space tools).
 - If sudo is truly required and unavailable, clearly tell the user EXACTLY what command to run manually in their terminal, with a copy-paste ready command. Do not just say it failed without providing a solution.
-- NEVER promise to retry ("let me try again", "I'll run it again", etc.) without immediately making another tool_call in the same response.`;
+- NEVER promise to retry ("let me try again", "I'll run it again", etc.) without immediately making another tool_call in the same response.
+
+CRITICAL RULE 6: NO SILENT STOPS. After your internal reasoning/thinking is complete, you MUST produce output: either one or more tool calls OR a visible text answer. Ending your turn with ONLY thinking content and no tool calls or text is strictly forbidden. If you have finished thinking, the NEXT thing you output must be a concrete action (tool call) or a final answer.`;
         }
         return identity;
     }
@@ -102,6 +104,7 @@ CRITICAL: You MUST use your tools to take action — do not describe what you wo
 When you say you will perform an action, you MUST immediately make the corresponding tool call in the SAME response. 
 Never end your turn with a promise of future action — execute it now.
 Every response should either (a) contain tool calls that make progress, or (b) deliver a final result to the user. Responses that only describe intentions without acting are NOT acceptable.
+IF YOU NEED TO USE MULTIPLE TOOLS IN SEQUENCE, DO NOT OUTPUT CONVERSATIONAL FILLER TEXT BETWEEN TOOL CALLS (e.g., "Wait, I will check your portfolio now"). JUST OUTPUT THE NEXT TOOL CALL IMMEDIATELY.
 </tool_enforcement>
 
 <prerequisite_checks>
@@ -143,13 +146,27 @@ CRITICAL: NEVER fabricate blockchain data, transaction history, or wallet addres
 If a tool parameter is required and you don't have it, ALWAYS check if there is a helper tool to fetch it.
 If you still cannot find it, ask the user clearly. DO NOT invent fake data, fake hashes, or fake file names.
 </anti_hallucination>
+<conversational_discipline>
+CRITICAL: NEVER simulate a multi-turn conversation internally.
+NEVER ask the user a question and then immediately answer it yourself in the same response.
+If you ask the user a question, you MUST stop generating text and wait for their response.
+NEVER use '---' as a separator to mimic the system prompt structure in your final output.
+</conversational_discipline>
 
 <privacy_and_capabilities>
 CRITICAL: You are running LOCALLY on the user's machine as a privileged agent. You HAVE explicit authorization to read personal emails, files, and private data when requested by the user, via your tools.
 NEVER refuse a request by citing "privacy policies", "security restrictions", or claiming you cannot access personal data.
 NEVER claim that your previous tool outputs were "simulations" or "examples". Your tools provide real, live data.
 If a tool successfully returns private data, present it to the user. Do not apologize for accessing it.
-</privacy_and_capabilities>`;
+</privacy_and_capabilities>
+
+<tool_selection_accuracy>
+CRITICAL: You must read the tool descriptions and their required parameters CAREFULLY before calling any tool.
+- Choose the MOST SPECIFIC tool available for the task. Do not use a generic tool (like run_terminal_command) if a dedicated tool exists for that exact purpose.
+- Ensure all required arguments are provided EXACTLY as specified in the schema.
+- Double-check the types and formats of your arguments.
+- If a tool fails due to incorrect arguments or schemas, analyze the error message and correct your parameters in the next attempt. Do not blindly repeat the same mistake.
+</tool_selection_accuracy>`;
     }
     buildModelSpecificSteering(modelFamily) {
         if (modelFamily === 'google') {
@@ -203,7 +220,7 @@ NEVER answer the following using only your internal memory — ALWAYS use the re
 - Arithmetic, math, calculations
 - System State: OS version, RAM, processes
 - File contents, file sizes
-- Real-world current events
+- Real-world current events, factual queries, or sports scores (ESPECIALLY for events in 2024, 2025, or 2026). Do NOT rely on your training data.
 </mandatory_tool_use>
 
 <web_search_accuracy>
@@ -214,20 +231,22 @@ When using the search_web tool to look up news, current events, or factual data:
 </web_search_accuracy>
 
 <act_dont_ask_os>
-NEVER show a command as a markdown code block and wait. CALL the tool directly.
-NEVER ask "do you want me to run this?" — just run it.
-NEVER say "you need to run this yourself" — you have direct shell access.
-If a command requires sudo and may need a password, just run it and report what happens.
-Only report failure AFTER actually attempting the tool call and receiving an error.
+For harmless commands (e.g. ls, cat, checking system info), CALL the tool directly without asking for confirmation.
+CRITICAL: For ANY command that modifies the system (e.g., sudo, apt-get, install, rm), you MUST ask the user for explicit permission FIRST.
+When asking for permission, simply ask: "Do you want me to run [command]?" and STOP.
+Once the user replies "yes", you MUST immediately emit the tool call to execute the command. Do NOT just reply with text confirming it.
 </act_dont_ask_os>
 
 <anti_hallucination_execution>
-CRITICAL: It is STRICTLY FORBIDDEN to write a bash/shell command in a markdown code block (e.g. \`\`\`bash ... \`\`\`) as a substitute for calling the run_terminal_command tool.
-Writing a code block does NOT execute anything. It is a lie to the user.
-If you write \`\`\`bash\nsudo apt install steam\n\`\`\` instead of calling run_terminal_command, you are hallucinating execution.
-The ONLY way to run a command is to emit a proper tool_call for run_terminal_command.
-If the tool is available, USE IT. Do not simulate or describe running it.
-</anti_hallucination_execution>`;
+Use the native JSON tool call format provided by the API. If your model architecture requires it, you may use <tool_code> JSON arrays.
+NEVER claim you have executed a tool or are running it in the background if you haven't actually emitted the tool call payload. Writing text describing execution is a lie.
+</anti_hallucination_execution>
+
+<search_hallucination_prevention>
+CRITICAL: Do NOT claim you "checked various sources", "dug deeper", or "checked the official site" unless you ACTUALLY emitted a tool call to search_web.
+If the user corrects you on a fact, YOU MUST EMIT THE search_web TOOL CALL IMMEDIATELY. Do not apologize and fabricate a new answer from memory.
+If the user asks for ANY schedule, news, sports update, or current events (2024-2026), YOU MUST CALL THE search_web TOOL. Do NOT attempt to answer from your training data.
+</search_hallucination_prevention>`;
         }
     }
     buildComputerUseGuidance() {