nyxora 26.7.8 → 26.7.9

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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.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/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
@@ -177,21 +177,82 @@ CRITICAL INSTRUCTIONS:
                 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 })
+                            }
+                        });
+                    }
+                }
+                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, '').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);
+                }
+            }
+            // -----------------------------------------------------
             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;
@@ -373,13 +434,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 },
@@ -411,11 +477,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 +562,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 +583,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 +611,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 +636,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>
@@ -227,7 +244,13 @@ 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>`;
+</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() {

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

@@ -146,21 +146,23 @@ async function runTaskPlanner(input, context) {
             messages: [
                 {
                     role: 'system',
-                    content: `You are a task planning assistant for a crypto AI agent.
-The user has a complex request that needs structured execution.
-Break it down into a clear, ordered execution plan with 3-6 concrete steps.
-Each step should map to a specific action or tool call.
-Be concise. Use bullet points. No fluff.
+                    content: `You are a concise task planning assistant.
+The user has a complex multi-step request. Output a brief, ordered execution plan with 3-5 bullet points (max 120 words total).
+Each bullet = one concrete action or tool call.
+Be extremely concise. No intros, no explanations.
 Context domain: ${context}`
                 },
-                { role: 'user', content: `Create an execution plan for: ${input}` }
+                { role: 'user', content: `Plan execution for: ${input}` }
             ]
         }));
         const plan = planRes.message?.content?.trim() || '';
         if (!plan)
             return '';
+        // Enforce max length — truncate to ~120 words to prevent context bloat
+        const words = plan.split(/\s+/);
+        const trimmedPlan = words.length > 120 ? words.slice(0, 120).join(' ') + '...' : plan;
         console.log(picocolors_1.default.blue('[TaskPlanner] Plan generated, injecting into agent context.'));
-        return `\n\n--- 📋 TASK EXECUTION PLAN (follow this order) ---\n${plan}\n--- END PLAN ---\n`;
+        return `--- 📋 EXECUTION PLAN ---\n${trimmedPlan}\n--- END PLAN ---`;
     }
     catch {
         return ''; // planning is best-effort, never block the agent
@@ -224,14 +226,14 @@ async function processUserInput(input, role = 'user', onProgress, sessionId) {
     }
     else {
         // ── Fallback: LLM Router (untuk intent ambigu / percakapan umum) ─────────
-        const routerPrompt = `You are Nyxora's Semantic Intent Router. Your job is to classify the user's FINAL message into one of four categories: 'web3', 'os', 'compound', or 'general'.
+        const routerPrompt = `You are Nyxora's Semantic Intent Router. Classify the user's FINAL message into one of four categories: 'web3', 'os', 'compound', or 'general'.
 Rules:
 1. FOCUS ONLY ON THE FINAL MESSAGE. History is only for context.
 2. The user may speak in ANY language, including casual slang, idioms, or abbreviations.
-3. If the core intent involves BOTH blockchain/finance AND system automation/files/emails, reply 'compound'.
+3. 'compound' is EXTREMELY RARE. Only reply 'compound' when the user EXPLICITLY requests BOTH a blockchain/crypto action AND an OS/file/email action in the SAME message. Example: "swap 1 ETH to USDC and email me the receipt". If in doubt, do NOT use 'compound'.
 4. If the core intent involves ONLY blockchain, crypto, bridging, swapping, trading, sending/receiving, tokens, wallets, transactions, OR asking for the price/conversion of ANY asset to fiat, reply 'web3'.
 5. If the core intent involves ONLY OS automation, weather, emails, files, terminal, changing AI settings, OR asking ANY question that requires a web search or real-world factual lookup (e.g., 'who won the game', 'what is the registration date', 'cek info', 'cari tahu'), reply 'os'.
-6. If it is purely casual conversation, chit-chat, or greetings, reply 'general'.
+6. If the message is casual conversation, chit-chat, greetings, capability questions (e.g., 'what can you do?', 'bisa ngapain?', 'help', 'menu'), or any open-ended/vague question, reply 'general'.
 Reply with EXACTLY ONE WORD: compound, web3, os, or general.`;
         const routerMessages = [
             { role: 'system', content: routerPrompt },
@@ -244,7 +246,7 @@ Reply with EXACTLY ONE WORD: compound, web3, os, or general.`;
                     model: config.llm.model,
                     messages: routerMessages,
                     temperature: 0.1,
-                    max_tokens: 1000
+                    max_tokens: 10
                 });
             }, 3); // 3 retries for transient 503/429 errors
             let contextResponse = (routerResponse.message.content || 'general').toLowerCase().trim();
@@ -284,18 +286,22 @@ Reply with EXACTLY ONE WORD: compound, web3, os, or general.`;
         console.log(picocolors_1.default.magenta(`[Orchestrator] Intent classified as: ${context.toUpperCase()}`));
     }
     if (context === 'web3') {
-        // P7: Inject task plan for complex requests
-        const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'web3') : '';
-        if (planInjection) {
-            // Prepend plan as a system note in the input so agent sees it
-            return await (0, web3Agent_1.processWeb3Intent)(planInjection + '\n\nUSER REQUEST: ' + input, role, onProgress, sessionId);
+        // P7: Inject task plan as a system note (NOT prepended to user input to avoid context bloat)
+        if (shouldPlan(input)) {
+            const planInjection = await runTaskPlanner(input, 'web3');
+            if (planInjection) {
+                // Inject plan as system message — visible to LLM but doesn't pollute user message size
+                exports.logger.addEntry({ role: 'system', content: planInjection }, sessionId);
+            }
         }
         return await (0, web3Agent_1.processWeb3Intent)(input, role, onProgress, sessionId);
     }
     else if (context === 'os') {
-        const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'os') : '';
-        if (planInjection) {
-            return await (0, osAgent_1.processOsIntent)(planInjection + '\n\nUSER REQUEST: ' + input, role, onProgress, sessionId);
+        if (shouldPlan(input)) {
+            const planInjection = await runTaskPlanner(input, 'os');
+            if (planInjection) {
+                exports.logger.addEntry({ role: 'system', content: planInjection }, sessionId);
+            }
         }
         return await (0, osAgent_1.processOsIntent)(input, role, onProgress, sessionId);
     }
@@ -396,14 +402,14 @@ async function processUserInputStream(input, originalOnChunk, onProgress, sessio
             preCheckMatched = true;
         }
         if (!preCheckMatched) {
-            const routerPrompt = `You are Nyxora's Semantic Intent Router. Your job is to classify the user's FINAL message into one of four categories: 'web3', 'os', 'compound', or 'general'.
+            const routerPrompt = `You are Nyxora's Semantic Intent Router. Classify the user's FINAL message into one of four categories: 'web3', 'os', 'compound', or 'general'.
 Rules:
 1. FOCUS ONLY ON THE FINAL MESSAGE. History is only for context.
 2. The user may speak in ANY language, including casual slang, idioms, or abbreviations.
-3. If the core intent involves BOTH blockchain/finance AND system automation/files/emails, reply 'compound'.
+3. 'compound' is EXTREMELY RARE. Only reply 'compound' when the user EXPLICITLY requests BOTH a blockchain/crypto action AND an OS/file/email action in the SAME message. Example: "swap 1 ETH to USDC and email me the receipt". If in doubt, do NOT use 'compound'.
 4. If the core intent involves ONLY blockchain, crypto, bridging, swapping, trading, sending/receiving, tokens, wallets, transactions, OR asking for the price/conversion of ANY asset to fiat, reply 'web3'.
 5. If the core intent involves ONLY OS automation, weather, emails, files, terminal, changing AI settings, OR asking ANY question that requires a web search or real-world factual lookup (e.g., 'who won the game', 'what is the registration date', 'cek info', 'cari tahu'), reply 'os'.
-6. If it is purely casual conversation, chit-chat, or greetings, reply 'general'.
+6. If the message is casual conversation, chit-chat, greetings, capability questions (e.g., 'what can you do?', 'bisa ngapain?', 'help', 'menu'), or any open-ended/vague question, reply 'general'.
 Reply with EXACTLY ONE WORD: compound, web3, os, or general.`;
             const routerMessages = [
                 { role: 'system', content: routerPrompt },
@@ -411,7 +417,7 @@ Reply with EXACTLY ONE WORD: compound, web3, os, or general.`;
                 { role: 'user', content: input }
             ];
             try {
-                const routerResponse = await (0, llmUtils_1.executeWithRetry)(async (client) => client.chat({ model: config.llm.model, messages: routerMessages, temperature: 0.1, max_tokens: 1000 }), 3);
+                const routerResponse = await (0, llmUtils_1.executeWithRetry)(async (client) => client.chat({ model: config.llm.model, messages: routerMessages, temperature: 0.1, max_tokens: 10 }), 3);
                 const cr = (routerResponse.message.content || 'general').toLowerCase().trim();
                 if (cr.includes('compound')) {
                     console.log(picocolors_1.default.cyan('[Stream Orchestrator] Compound intent detected via LLM Router.'));
@@ -449,15 +455,23 @@ Reply with EXACTLY ONE WORD: compound, web3, os, or general.`;
         console.log(picocolors_1.default.cyan(`[Stream Orchestrator] Intent classified as: ${context.toUpperCase()}`));
         let finalResult = '';
         if (context === 'web3') {
-            // P7: Inject task plan for complex stream requests
-            const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'web3') : '';
-            const streamInput = planInjection ? planInjection + '\n\nUSER REQUEST: ' + input : input;
-            finalResult = await (0, web3Agent_2.processWeb3IntentStream)(streamInput, onChunk, onProgress, sessionId);
+            // P7: Inject task plan as a system note (NOT prepended to user input to avoid context bloat)
+            if (shouldPlan(input)) {
+                const planInjection = await runTaskPlanner(input, 'web3');
+                if (planInjection) {
+                    exports.logger.addEntry({ role: 'system', content: planInjection }, sessionId);
+                }
+            }
+            finalResult = await (0, web3Agent_2.processWeb3IntentStream)(input, onChunk, onProgress, sessionId);
         }
         else if (context === 'os') {
-            const planInjection = shouldPlan(input) ? await runTaskPlanner(input, 'os') : '';
-            const streamInput = planInjection ? planInjection + '\n\nUSER REQUEST: ' + input : input;
-            finalResult = await (0, osAgent_2.processOsIntentStream)(streamInput, onChunk, onProgress, sessionId);
+            if (shouldPlan(input)) {
+                const planInjection = await runTaskPlanner(input, 'os');
+                if (planInjection) {
+                    exports.logger.addEntry({ role: 'system', content: planInjection }, sessionId);
+                }
+            }
+            finalResult = await (0, osAgent_2.processOsIntentStream)(input, onChunk, onProgress, sessionId);
         }
         else {
             exports.logger.addEntry({ role: 'user', content: input }, sessionId);