nyxora 26.7.2 → 26.7.4

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

@@ -5,32 +5,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.txManager = void 0;
 const crypto_1 = __importDefault(require("crypto"));
-const fs_1 = __importDefault(require("fs"));
-const paths_1 = require("../config/paths");
+const logger_1 = require("../memory/logger");
 class TransactionManager {
-    transactions = new Map();
-    withdrawals = new Map();
-    dbPath;
+    activePromises = new Set();
     constructor() {
-        this.dbPath = (0, paths_1.getPath)('.nyxora_withdrawals.json');
-        this.loadWithdrawals();
+        // Migration: if .nyxora_withdrawals.json exists, we could migrate it, but the plan says we can ignore/leave it.
+        // However, a simple migration log is fine if we want to be safe.
     }
-    loadWithdrawals() {
-        if (fs_1.default.existsSync(this.dbPath)) {
-            try {
-                const data = fs_1.default.readFileSync(this.dbPath, 'utf8');
-                const parsed = JSON.parse(data);
-                parsed.forEach(w => this.withdrawals.set(w.id, w));
-            }
-            catch (e) {
-                console.error("Failed to load withdrawals DB:", e);
-            }
-        }
+    // --- PROMISE TRACKING (For Graceful Shutdown) ---
+    trackPromise(promise) {
+        this.activePromises.add(promise);
+        promise.finally(() => {
+            this.activePromises.delete(promise);
+        });
     }
-    saveWithdrawals() {
-        const data = Array.from(this.withdrawals.values());
-        fs_1.default.writeFileSync(this.dbPath, JSON.stringify(data, null, 2));
+    async waitForAll(timeoutMs = 10000) {
+        if (this.activePromises.size === 0)
+            return;
+        console.log(`[TransactionManager] Waiting for ${this.activePromises.size} active Web3 transactions to finish...`);
+        const timeout = new Promise(resolve => setTimeout(resolve, timeoutMs));
+        await Promise.race([
+            Promise.allSettled(Array.from(this.activePromises)),
+            timeout
+        ]);
+        if (this.activePromises.size > 0) {
+            console.log(`[TransactionManager] Warning: ${this.activePromises.size} transactions did not finish in time.`);
+        }
+        else {
+            console.log(`[TransactionManager] All transactions finished cleanly.`);
+        }
     }
+    // --- TRANSACTIONS (SQLite) ---
     createPendingTransaction(type, chainName, details) {
         const id = crypto_1.default.randomUUID();
         const nonce = crypto_1.default.randomBytes(16).toString('hex');
@@ -43,24 +48,25 @@ class TransactionManager {
             createdAt: Date.now(),
             nonce,
         };
-        this.transactions.set(id, tx);
+        logger_1.logger.savePendingTransaction(tx);
         return tx;
     }
     getPending() {
-        return Array.from(this.transactions.values()).filter(t => t.status === 'pending');
+        return logger_1.logger.getPendingTransactions();
     }
     getTransaction(id) {
-        return this.transactions.get(id);
+        return logger_1.logger.getTransaction(id);
     }
     updateStatus(id, status, result) {
-        const tx = this.transactions.get(id);
+        const tx = logger_1.logger.getTransaction(id);
         if (tx) {
             tx.status = status;
             if (result)
                 tx.result = result;
+            logger_1.logger.savePendingTransaction(tx);
         }
     }
-    // --- WITHDRAWAL LOGIC ---
+    // --- WITHDRAWALS (SQLite) ---
     createPendingWithdrawal(data) {
         const id = crypto_1.default.randomUUID();
         const withdrawal = {
@@ -69,18 +75,17 @@ class TransactionManager {
             status: 'WAITING_FOR_CHALLENGE',
             createdAt: Date.now()
         };
-        this.withdrawals.set(id, withdrawal);
-        this.saveWithdrawals();
+        logger_1.logger.savePendingWithdrawal(withdrawal);
         return withdrawal;
     }
     getPendingWithdrawals() {
-        return Array.from(this.withdrawals.values()).filter(w => w.status !== 'COMPLETED');
+        return logger_1.logger.getPendingWithdrawals();
     }
     updateWithdrawalStatus(id, status) {
-        const w = this.withdrawals.get(id);
+        const w = logger_1.logger.getPendingWithdrawals().find(x => x.id === id);
         if (w) {
             w.status = status;
-            this.saveWithdrawals();
+            logger_1.logger.savePendingWithdrawal(w);
         }
     }
 }

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

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 exports.processWeb3Intent = processWeb3Intent;
+exports.processWeb3IntentStream = processWeb3IntentStream;
+const fs_1 = __importDefault(require("fs"));
 const parser_1 = require("../config/parser");
 const logger_1 = require("../memory/logger");
 const tracker_1 = require("../gateway/tracker");
@@ -12,7 +14,11 @@ const episodic_1 = require("../memory/episodic");
 const skillManager_1 = require("../utils/skillManager");
 const registry_1 = require("../plugin/registry");
 const cognitiveManager_1 = require("../cognitive/cognitiveManager");
+const reasoningScratchpad_1 = require("./reasoningScratchpad");
+const contextSummarizer_1 = require("../utils/contextSummarizer");
 const EXECUTION_DISCIPLINE = `
+
+
 <tool_persistence>
 Use tools whenever they can increase the accuracy, completeness, or factual correctness of your response.
 Do NOT stop early if another tool call would materially improve the result.
@@ -21,12 +27,21 @@ Continue using tools until the task is completely finished and verified.
 
 <mandatory_tool_use>
 NEVER answer the following using only your internal memory — ALWAYS use the relevant tool:
+- Cryptocurrency prices, market data, and portfolio values (e.g., use get_price_and_fiat_value)
+- Fiat exchange rates or currency conversions (fetch live rates, never guess)
 - Arithmetic, math, calculations
 - System State: OS version, RAM, processes
 - File contents, file sizes
 - Real-world current events
 </mandatory_tool_use>
 
+<fiat_conversion_rule>
+CRITICAL: If the user asks for the total fiat value of a certain amount of crypto (e.g., "3821 jrny to idr", "2 eth in usd", "cek saldo gue dirupiahin"), you MUST pass that amount into the 'get_price_and_fiat_value' tool's 'amount' parameter.
+You MUST also set the 'currency' parameter in 'get_price_and_fiat_value' ONLY IF the user explicitly requests a specific currency. If no specific currency is requested, LEAVE THE 'currency' PARAMETER BLANK so the system can use the user's default.
+NEVER fetch the price and then manually multiply it by the amount in your head. The LLM is prohibited from performing fiat multiplication. ALWAYS use the 'amount' parameter in 'get_price_and_fiat_value' to guarantee mathematical precision.
+NEVER use the 'analyze_market' tool if the user is only asking to check their balance in fiat/rupiah. 'analyze_market' does not do fiat conversion.
+</fiat_conversion_rule>
+
 <act_dont_ask>
 When a user's request has a clear, standard interpretation, take immediate ACTION instead of asking for clarification.
 </act_dont_ask>
@@ -36,21 +51,21 @@ The deliverable must be a working artifact backed by real tool output — not ju
 NEVER fabricate, hallucinate, or forge tool outputs.
 </task_completion>
 `;
+const paths_1 = require("../config/paths");
 const picocolors_1 = __importDefault(require("picocolors"));
 exports.logger = new logger_1.Logger();
 const llmUtils_1 = require("../utils/llmUtils");
-function getSystemPrompt(context = 'web3', userInput = '') {
+async function getSystemPrompt(context = 'web3', userInput = '') {
     const config = (0, parser_1.loadConfig)();
-    const currentDateTime = new Date().toLocaleString('en-US');
     let basePrompt = `You are Nyxora's Web3 Agent (DeFi Specialist).
-The current real-world date and time is: ${currentDateTime}.
+Current Time: ${new Date().toISOString()}
 Default Chain: ${config.agent.default_chain}
 
 Reason internally. Never reveal private reasoning. Provide only concise conclusions, assumptions, and actionable steps.
 
 [WEB3 EXECUTION WORKFLOW]
 CRITICAL RULE 1: NEVER expose internal JSON tool calls. Explain the outcome naturally.
-CRITICAL RULE 2: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt.
+CRITICAL RULE 2: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt, UNLESS the Episodic Memories or Cognitive Skills specify a strict language preference.
 CRITICAL RULE 3: DEFAULT CHAIN HANDLING. Default to: ${config.agent.default_chain} unless specified.
 CRITICAL RULE 4: CONDITIONAL PARALLEL EXECUTION. Parallel tool execution is ONLY allowed if there are zero data dependencies.
 CRITICAL RULE 5: TRANSACTION EXECUTION. For ALL state-changing transactions (swap, bridge, transfer), execute IMMEDIATELY. It will trigger a secure popup.
@@ -61,54 +76,89 @@ CRITICAL RULE 9: MARKET CONFIDENCE SCORE. Declare a 'Confidence Score (0-100%)'
 
 ${EXECUTION_DISCIPLINE}
 `;
-    // Inject Episodic Memories
+    // Inject Episodic Memories via Python RAG
     try {
-        const recentMemories = episodic_1.episodicDB.getMemories().slice(0, 10);
-        if (recentMemories.length > 0) {
-            basePrompt += `
-
---- EPISODIC MEMORIES (SMART SUGGESTIONS) ---
-`;
-            recentMemories.forEach(mem => {
-                basePrompt += `- [${mem.category.toUpperCase()}] ${mem.fact} (Confidence: ${(mem.confidence * 100).toFixed(0)}%)
-`;
-            });
+        const ragRes = await fetch('http://127.0.0.1:8000/memory/rag', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query: userInput, top_k: 5 })
+        });
+        if (ragRes.ok) {
+            const ragData = await ragRes.json();
+            if (ragData.memories && ragData.memories.length > 0) {
+                basePrompt += `\n\n--- EPISODIC MEMORIES (SMART SUGGESTIONS) ---\n`;
+                ragData.memories.forEach((mem) => {
+                    basePrompt += `- ${mem}\n`;
+                });
+            }
         }
     }
-    catch { }
+    catch (e) {
+        // Fallback or ignore if Python ML engine is down
+    }
     // Inject Active Cognitive Skills
     const activeSOP = cognitiveManager_1.cognitiveManager.loadActiveCognitiveSkills(userInput);
     if (activeSOP) {
         basePrompt += `\n\n[ACTIVE COGNITIVE SKILLS]\n${activeSOP}\n`;
     }
+    // Inject User Information & Personas from user.md
+    try {
+        const userMdPath = (0, paths_1.getPath)('user.md');
+        if (fs_1.default.existsSync(userMdPath)) {
+            const userInstructions = fs_1.default.readFileSync(userMdPath, 'utf8');
+            basePrompt += `\n\n--- USER INFORMATION & PREFERENCES ---\n${userInstructions}\n`;
+        }
+    }
+    catch (e) {
+        // Ignore error
+    }
+    // HIGHEST PRIORITY: Inject observed user communication style (NyxDaemon)
+    try {
+        const strongPersonas = episodic_1.episodicDB.getStrongPersonas(0.5);
+        if (strongPersonas.length > 0) {
+            basePrompt += `\n\n--- ⚡ OVERRIDE: USER COMMUNICATION STYLE (HIGHEST PRIORITY — OVERRIDES ALL RULES ABOVE) ---\n`;
+            basePrompt += `CRITICAL: These are CONFIRMED user preferences observed across multiple conversations. You MUST apply them IMMEDIATELY and CONSISTENTLY, overriding any default tone or style instructions above.\n\n`;
+            strongPersonas.forEach(p => {
+                const label = p.category ? `[${p.category.toUpperCase()}]` : '[PREFERENCE]';
+                basePrompt += `${label} ${p.trait}\n`;
+            });
+        }
+    }
+    catch (e) {
+        // Ignore
+    }
     return basePrompt;
 }
 async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
     const config = (0, parser_1.loadConfig)();
     // Add input to memory
     exports.logger.addEntry({ role, content: input }, sessionId);
-    const history = exports.logger.getHistory(sessionId);
-    // Format messages for OpenAI
-    // Inject Plugin Tools dynamically
     const pluginTools = registry_1.pluginManager.getAllToolDefinitions();
     let activeTools = [...pluginTools];
     activeTools = activeTools.filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
+    // P1: Init reasoning scratchpad for this request
+    const scratchpad = new reasoningScratchpad_1.ReasoningScratchpad();
+    // P3: Build system prompt ONCE per request — not per turn
+    const cachedSystemPrompt = await getSystemPrompt('web3', input);
     const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
-    const sanitizedHistory = sanitizeHistoryForLLM(history, activeTools, config.llm.provider);
-    let messages = [
-        { role: 'system', content: getSystemPrompt('web3', input) },
-        ...sanitizedHistory
-    ];
     try {
-        const context = 'web3';
         let turnCount = 0;
-        const MAX_TURNS = 10;
+        const MAX_TURNS = 20;
+        let consecutiveToolErrors = 0;
         while (turnCount < MAX_TURNS) {
             turnCount++;
             const currentHistory = exports.logger.getHistory(sessionId);
-            const sanitizedHistory = sanitizeHistoryForLLM(currentHistory, activeTools, config.llm.provider);
+            // P6: Compress history if conversation is too long
+            const historyToUse = (0, contextSummarizer_1.needsCompression)(currentHistory)
+                ? await (0, contextSummarizer_1.compressHistory)(currentHistory)
+                : currentHistory;
+            const sanitizedHistory = sanitizeHistoryForLLM(historyToUse, activeTools, config.llm.provider);
+            // P1: Inject scratchpad into system prompt for turns > 1
+            const sysPrompt = turnCount === 1
+                ? cachedSystemPrompt
+                : cachedSystemPrompt + scratchpad.getInjection();
             const messages = [
-                { role: 'system', content: getSystemPrompt('web3', input) },
+                { role: 'system', content: sysPrompt },
                 ...sanitizedHistory
             ];
             const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
@@ -127,16 +177,59 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
                 tracker_1.Tracker.addTokens(response.usage.total_tokens, config.llm.provider);
             }
             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);
             exports.logger.addEntry({
                 role: 'assistant',
-                content: responseMessage.content || "",
+                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 = [];
+                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)
+                        }
+                    });
+                }
+                if (fallbacks.length > 0) {
+                    responseMessage.tool_calls = fallbacks;
+                    responseMessage.content = responseMessage.content.replace(/^\/[a-zA-Z0-9_]+\s+.*$/gm, '').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) {
-                let finalContent = responseMessage.content || "No response generated.";
-                finalContent = finalContent.replace(/<(think|thought|thinking|reasoning|analysis|reflection)>[\s\S]*?<\/\1>\n?/gi, '');
-                finalContent = finalContent.trim();
-                return finalContent;
+                return cleanedContent || 'No response generated.';
             }
             let canFastReturnAll = true;
             let accumulatedResults = [];
@@ -144,7 +237,7 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
             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', 'confirm_pending_tx'
             ];
             for (const _toolCall of responseMessage.tool_calls) {
                 const toolCall = _toolCall;
@@ -212,8 +305,26 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
                     canFastReturnAll = false;
                 }
             }
-            // V2 Optimization (Expanded in v1.7.4): Zero-LLM Fast Return for data-heavy and read-only tools
-            // If all tools already return perfectly formatted markdown, skip the second LLM call to save 5-10s latency!
+            // P4: Self-reflection — if ALL tools failed, inject reflection before next turn
+            const allFailed = accumulatedResults.length > 0 && accumulatedResults.every(r => r.startsWith('Error') || r.includes('[System Error]') || r.includes('[Security Blocked]'));
+            if (allFailed) {
+                consecutiveToolErrors++;
+                const reflection = `[SELF-REFLECTION] All ${accumulatedResults.length} tool call(s) failed (attempt ${consecutiveToolErrors}). ` +
+                    `Errors: ${accumulatedResults.join(' | ')}. ` +
+                    `Analyze WHY each failed. Options: (1) retry with corrected params, (2) use alternative tool, (3) inform user clearly. ` +
+                    `Do NOT repeat the exact same failed call.`;
+                exports.logger.addEntry({ role: 'system', content: reflection }, sessionId);
+                console.log(picocolors_1.default.magenta(`[Self-Reflection] Turn ${turnCount}: all tools failed, injecting reflection.`));
+                if (consecutiveToolErrors >= 2) {
+                    const errorSummary = `⚠️ Unable to complete this request after multiple attempts.\n${accumulatedResults.join('\n')}`;
+                    exports.logger.addEntry({ role: 'assistant', content: errorSummary }, sessionId);
+                    return errorSummary;
+                }
+            }
+            else {
+                consecutiveToolErrors = 0;
+            }
+            // 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);
@@ -221,7 +332,7 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
             }
             // Loop continues, sending tool results in the next turn
         }
-        const maxTurnMsg = "⚠️ Reached maximum interaction limit (10 turns). Please be more specific.";
+        const maxTurnMsg = "⚠️ Reached maximum interaction limit (20 turns). Please be more specific.";
         exports.logger.addEntry({ role: 'assistant', content: maxTurnMsg }, sessionId);
         return maxTurnMsg;
     }
@@ -236,3 +347,118 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
         return errorMsg;
     }
 }
+async function processWeb3IntentStream(input, onChunk, onProgress, sessionId) {
+    const config = (0, parser_1.loadConfig)();
+    exports.logger.addEntry({ role: 'user', content: input }, sessionId);
+    const pluginTools = registry_1.pluginManager.getAllToolDefinitions();
+    let activeTools = [...pluginTools].filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
+    const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
+    try {
+        let turnCount = 0;
+        const MAX_TURNS = 20;
+        let fullResponse = '';
+        while (turnCount < MAX_TURNS) {
+            turnCount++;
+            const currentHistory = exports.logger.getHistory(sessionId);
+            const sanitizedHistory = sanitizeHistoryForLLM(currentHistory, activeTools, config.llm.provider);
+            const messages = [
+                { role: 'system', content: await getSystemPrompt('web3', input) },
+                ...sanitizedHistory
+            ];
+            let streamedContent = '';
+            const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
+                return await client.stream({ model: config.llm.model, temperature: config.llm.temperature, messages, tools: activeTools }, (chunk) => {
+                    streamedContent += chunk;
+                    onChunk(chunk);
+                });
+            });
+            const responseMessage = response.message;
+            if (turnCount === 1)
+                tracker_1.Tracker.addMessage();
+            if (response.usage?.total_tokens)
+                tracker_1.Tracker.addTokens(response.usage.total_tokens, config.llm.provider);
+            tracker_1.Tracker.addEvent('llm.response', { provider: config.llm.provider, tool_calls: responseMessage.tool_calls?.length || 0 });
+            exports.logger.addEntry({
+                role: 'assistant',
+                content: responseMessage.content || '',
+                tool_calls: responseMessage.tool_calls,
+            }, sessionId);
+            if (!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) {
+                let finalContent = responseMessage.content || 'No response generated.';
+                finalContent = finalContent.replace(/<(think|thought|thinking|reasoning|analysis|reflection)[\s\S]*?<\/\1>\n?/gi, '').trim();
+                fullResponse = finalContent;
+                break;
+            }
+            // Tool calls detected — pause stream visually and execute tools
+            const fastReturnTools = ['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3', 'confirm_pending_tx'];
+            let canFastReturnAll = true;
+            const accumulatedResults = [];
+            for (const _toolCall of responseMessage.tool_calls) {
+                const toolCall = _toolCall;
+                const toolName = toolCall.function.name;
+                let result = '';
+                let args = {};
+                console.log(picocolors_1.default.yellow(`[⚡ Tool Execution] AI is calling ${toolName}...`));
+                if (onProgress)
+                    onProgress(`_⚡ Running tool: ${toolName}..._`);
+                try {
+                    let argStr = toolCall.function.arguments;
+                    if (argStr && !argStr.trim().endsWith('}'))
+                        argStr += '}';
+                    args = JSON.parse(argStr);
+                }
+                catch (parseError) {
+                    result = `[System Error] Arguments for ${toolName} must be valid JSON. Error: ${parseError.message}`;
+                    exports.logger.addEntry({ role: 'tool', tool_call_id: toolCall.id, content: result }, sessionId);
+                    continue;
+                }
+                if (!(0, skillManager_1.isSkillActive)(toolName)) {
+                    result = `[System Error] Access denied: Skill '${toolName}' is currently disabled.`;
+                    exports.logger.addEntry({ role: 'tool', tool_call_id: toolCall.id, content: result }, sessionId);
+                    continue;
+                }
+                try {
+                    const pluginResult = await registry_1.pluginManager.executeTool(toolName, args, { sessionId });
+                    result = pluginResult !== null ? pluginResult : `Error: Tool ${toolName} is not implemented.`;
+                    if (result.includes('[Security Blocked]') || result.startsWith('Error:')) {
+                        console.log(picocolors_1.default.red(`[❌ Failed] Tool ${toolName} returned an error or was blocked.`));
+                    }
+                    else {
+                        console.log(picocolors_1.default.green(`[✅ Success] Tool ${toolName} executed successfully.`));
+                    }
+                }
+                catch (toolError) {
+                    result = `Error executing ${toolName}: ${toolError.message}`;
+                    console.error(picocolors_1.default.red(`[❌ Error Crash] Execution of ${toolName} failed: ${toolError.message}`));
+                }
+                exports.logger.addEntry({ role: 'tool', tool_call_id: toolCall.id, name: toolName, content: result }, sessionId);
+                accumulatedResults.push(result);
+                if (!fastReturnTools.includes(toolName))
+                    canFastReturnAll = false;
+            }
+            if (canFastReturnAll && accumulatedResults.length > 0) {
+                const finalContent = accumulatedResults.join('\n\n---\n\n');
+                exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
+                onChunk(finalContent);
+                fullResponse = finalContent;
+                break;
+            }
+        }
+        if (!fullResponse) {
+            const maxTurnMsg = '⚠️ Reached maximum interaction limit (20 turns). Please be more specific.';
+            exports.logger.addEntry({ role: 'assistant', content: maxTurnMsg }, sessionId);
+            fullResponse = maxTurnMsg;
+        }
+        return fullResponse;
+    }
+    catch (error) {
+        console.error('LLM Stream Error:', error);
+        const status = error?.status || error?.response?.status;
+        let errorMsg = '⚠️ All models are temporarily rate-limited. Please try again in a few minutes.';
+        if (status === 400 || (error.message && error.message.toLowerCase().includes('invalid'))) {
+            errorMsg = '⚠️ Failed to parse instruction. Please describe your command more specifically.';
+        }
+        exports.logger.addEntry({ role: 'assistant', content: errorMsg }, sessionId);
+        return errorMsg;
+    }
+}

package/dist/packages/core/src/cognitive/cognitiveManager.js

@@ -14,31 +14,84 @@ class CognitiveManager {
     loadActiveCognitiveSkills(intent) {
         const activeSOPs = [];
         const lowerIntent = intent.toLowerCase();
-        // Mapping of keywords to SOP paths
-        const skillMappings = [
+        // ── Software Development SOPs ──────────────────────────────────────────
+        const devSkillMappings = [
             {
-                keywords: ['debug', 'error', 'bug', 'fix', 'crash', 'fail', 'trace'],
+                keywords: ['debug', 'error', 'bug', 'fix', 'crash', 'fail', 'trace', 'exception', 'undefined', 'null'],
                 file: 'software-development/systematic-debugging.md'
             },
             {
-                keywords: ['tdd', 'test', 'red green', 'unit test', 'jest', 'mocha'],
+                keywords: ['tdd', 'test', 'red green', 'unit test', 'jest', 'mocha', 'vitest'],
                 file: 'software-development/test-driven-development.md'
             },
             {
-                keywords: ['plan', 'architecture', 'design', 'structure', 'blueprint'],
+                keywords: ['plan', 'architecture', 'design', 'structure', 'blueprint', 'refactor'],
                 file: 'software-development/plan.md'
             },
+        ];
+        // ── Web3 / Trading SOPs ────────────────────────────────────────────────
+        //
+        // NOTE FOR CONTRIBUTORS: Keyword arrays are intentionally multilingual.
+        // Nyxora is a global product used by speakers of many languages.
+        // Each array includes English terms (primary) and Indonesian terms (id)
+        // as the initial non-English locale. Additional languages can be added
+        // to each keywords array without changing any other code.
+        //
+        const web3SkillMappings = [
             {
-                keywords: ['binance', 'spot trading', 'exchange trading', 'cex trading', 'api key'],
-                file: 'autonomous/binance-trading-integration.md'
-            }
+                // Market analysis: price action, momentum, trend direction
+                keywords: [
+                    // English
+                    'analysis', 'market', 'chart', 'rsi', 'ma50', 'momentum',
+                    'signal', 'bullish', 'bearish', 'trend', 'price', 'pump', 'dump',
+                    // Indonesian (id)
+                    'analisis', 'harga',
+                ],
+                file: 'web3/market-analysis.md'
+            },
+            {
+                // Risk assessment: security, liquidity, holder concentration
+                keywords: [
+                    // English
+                    'risk', 'safe', 'honeypot', 'rug', 'scam', 'dangerous',
+                    'liquidity', 'security', 'holder',
+                    // Indonesian (id)
+                    'risiko', 'aman', 'likuiditas', 'keamanan',
+                ],
+                file: 'web3/risk-assessment.md'
+            },
+            {
+                // Trade planning: entry/exit strategy, order types
+                keywords: [
+                    // English
+                    'trade', 'trading', 'entry', 'exit', 'buy', 'sell',
+                    'swap', 'position', 'stop loss', 'take profit', 'tp', 'sl',
+                    'strategy', 'dca', 'limit order',
+                    // Indonesian (id)
+                    'beli', 'jual', 'posisi', 'strategi',
+                ],
+                file: 'web3/trade-planning.md'
+            },
+            {
+                // Portfolio review: holdings, rebalancing, allocation
+                keywords: [
+                    // English
+                    'portfolio', 'balance', 'rebalance', 'holdings',
+                    'asset', 'diversif', 'allocation',
+                    // Indonesian (id)
+                    'portofolio', 'saldo', 'aset', 'alokasi',
+                ],
+                file: 'web3/portfolio-review.md'
+            },
         ];
-        for (const mapping of skillMappings) {
+        const allMappings = [...devSkillMappings, ...web3SkillMappings];
+        for (const mapping of allMappings) {
             if (mapping.keywords.some(kw => lowerIntent.includes(kw))) {
                 const fullPath = path_1.default.join(this.promptsPath, mapping.file);
                 if (fs_1.default.existsSync(fullPath)) {
                     const content = fs_1.default.readFileSync(fullPath, 'utf8');
-                    activeSOPs.push(`--- COGNITIVE SKILL: ${path_1.default.basename(mapping.file, '.md').toUpperCase()} ---\n${content}`);
+                    const skillName = path_1.default.basename(mapping.file, '.md').toUpperCase().replace(/-/g, ' ');
+                    activeSOPs.push(`--- COGNITIVE SKILL: ${skillName} ---\n${content}`);
                 }
             }
         }