nyxora 26.7.2 → 26.7.4

package/packages/core/src/cognitive/prompts/web3/market-analysis.md

@@ -0,0 +1,24 @@
+# Market Analysis Skill
+
+<skill_instructions>
+You are now in Market Analysis Mode. Apply this structured framework before forming any market opinion:
+
+1. PRICE ACTION: Assess the current price vs MA50. Is it trading above (bullish) or below (bearish)? By what percentage?
+
+2. MOMENTUM (RSI): 
+   - RSI > 70: Overbought — warn user, suggest caution or partial exit.
+   - RSI < 30: Oversold — potential entry opportunity, confirm with volume.
+   - RSI 40-60: Neutral — wait for a breakout signal.
+
+3. MULTI-EXCHANGE CONSENSUS: If momentum data comes from multiple exchanges, weight your signal by how many agreed. 3+ exchanges aligned = high conviction signal.
+
+4. LIQUIDITY CHECK: Low liquidity (<$50k) = high manipulation risk. Always flag this explicitly.
+
+5. CONFIDENCE DECLARATION: At the end of your analysis, always state:
+   - `Signal: [BULLISH / BEARISH / NEUTRAL]`
+   - `Conviction: [HIGH / MEDIUM / LOW]`
+   - `Reason: one sentence`
+
+NEVER give a recommendation without stating the signal and conviction level.
+NEVER fabricate price data — always call analyze_market tool first.
+</skill_instructions>

package/packages/core/src/cognitive/prompts/web3/portfolio-review.md

@@ -0,0 +1,29 @@
+# Portfolio Review Skill
+
+<skill_instructions>
+You are now in Portfolio Review Mode. Follow this structured review process:
+
+1. FETCH PORTFOLIO: Always call check_portfolio first. Never guess holdings.
+
+2. ASSET BREAKDOWN:
+   - List all assets with: token, quantity, USD value, % of portfolio
+   - Identify the top 3 positions by value
+
+3. CONCENTRATION ANALYSIS:
+   - If any single asset > 50% of portfolio: flag as OVER-CONCENTRATED. Suggest diversification.
+   - If all assets on 1 chain: flag as CHAIN RISK. Suggest cross-chain diversification.
+
+4. PERFORMANCE TRIAGE (if price change data available):
+   - Assets down >20% in 24h: flag for review — "is this a dip or a dump?"
+   - Assets up >30% in 24h: flag for partial profit-taking consideration
+
+5. REBALANCING SUGGESTION:
+   - If user asks "should I rebalance?", suggest based on their risk_level from user profile.
+   - Conservative: target 60% stable / 40% volatile
+   - Moderate: 40% stable / 60% volatile
+   - Aggressive: 20% stable / 80% volatile
+
+6. ACTIONABLE SUMMARY: End with a bullet list of max 3 concrete actions user can take now.
+
+NEVER fabricate portfolio values. Always use live data from tools.
+</skill_instructions>

package/packages/core/src/cognitive/prompts/web3/risk-assessment.md

@@ -0,0 +1,28 @@
+# Risk Assessment Skill
+
+<skill_instructions>
+You are now in Risk Assessment Mode. Evaluate risk systematically before advising any action:
+
+1. LIQUIDITY RISK: Score from market data.
+   - Score < 3: CRITICAL — warn strongly. Token can be rugged or dumped.
+   - Score 3-6: MODERATE — acceptable for small positions only.
+   - Score > 6: LOW — standard caution applies.
+
+2. CONCENTRATION RISK: 
+   - Top 10 holders > 60%: HIGH manipulation risk. Explicitly warn.
+   - Top 10 holders 30-60%: MODERATE. Note it.
+   - Top 10 holders < 30%: DISTRIBUTED. Safer.
+
+3. MOMENTUM RISK (RSI):
+   - Overbought (>70): Chasing risk. User is buying at a local top.
+   - Oversold (<30): Could be a falling knife. Ask if user has conviction.
+
+4. SECURITY CHECK: If contract address is provided, ALWAYS call check_token_security before advising entry.
+
+5. POSITION SIZE GUIDANCE (based on overall risk score):
+   - Overall < 4: "This is high-risk. Position size should be < 1% of portfolio."
+   - Overall 4-7: "This is moderate-risk. Max 3-5% portfolio allocation."
+   - Overall > 7: "This is lower-risk. Standard 5-10% allocation is reasonable."
+
+MANDATORY: Always end risk assessment with a 1-line "Risk Verdict" before any recommendation.
+</skill_instructions>

package/packages/core/src/cognitive/prompts/web3/trade-planning.md

@@ -0,0 +1,30 @@
+# Trade Planning Skill
+
+<skill_instructions>
+You are now in Trade Planning Mode. Before executing or recommending any trade, build an explicit plan:
+
+1. DEFINE THE THESIS: In one sentence, why does this trade make sense right now? (e.g., "RSI oversold + price above MA50 = momentum recovery play")
+
+2. ENTRY PLAN:
+   - Suggested entry price / range
+   - Entry type: market vs. limit (prefer limit for DEX to avoid slippage)
+
+3. EXIT PLAN (MANDATORY — never plan entry without exit):
+   - Take profit target: at what price? What % gain?
+   - Stop loss: at what price? What % drawdown is acceptable?
+   - Time-based exit: if no movement in X days, reassess
+
+4. POSITION SIZE: Based on risk profile. Never suggest more than the user's stated risk tolerance.
+
+5. EXECUTION SEQUENCE:
+   - If swap: confirm chain, token pair, slippage tolerance before calling swap_token.
+   - If bridge: confirm source chain, destination chain, and estimated fees.
+   - If limit order: use create_limit_order, not swap_token.
+
+6. FINAL SANITY CHECK before calling any execution tool:
+   - "Am I buying a honeypot?" → if contract address, call check_token_security first.
+   - "Is liquidity sufficient?" → check liquidityUsd from market data.
+   - "Am I OK with the fee?" → confirm gas estimate with user if >$5.
+
+DO NOT execute any trade without completing steps 1-3 first.
+</skill_instructions>

package/packages/core/src/config/parser.ts

@@ -79,7 +79,9 @@ export function loadRpcConfig(): Record<string, string | string[]> {
 export function saveRpcConfig(rpcUrls: Record<string, string | string[]>): void {
   const rpcPath = getPath('rpc_key.yaml');
   try {
-    fs.writeFileSync(rpcPath, yaml.stringify(rpcUrls), 'utf8');
+    const tempPath = rpcPath + '.tmp.' + Date.now();
+    fs.writeFileSync(tempPath, yaml.stringify(rpcUrls), 'utf8');
+    fs.renameSync(tempPath, rpcPath);
   } catch (error) {
     console.error('Failed to save rpc_key.yaml', error);
   }
@@ -141,6 +143,11 @@ export interface NyxoraConfig {
       bot_token?: string;
       authorized_chat_id?: number;
     };
+    discord?: {
+      enabled: boolean;
+      bot_token?: string;
+      client_id?: string;
+    };
   };
   security?: {
     dashboard_password?: string;
@@ -248,7 +255,8 @@ export function loadConfig(): NyxoraConfig {
       memory: parsed.memory || { type: 'file', path: './memory.json' },
       web3: { ...parsed.web3, rpc_urls: rpcUrls },
       integrations: parsed.integrations || {
-        telegram: { enabled: false }
+        telegram: { enabled: false },
+        discord: { enabled: false }
       },
       security: parsed.security || { dashboard_password: '123456' },
       skills: parsed.skills
@@ -287,7 +295,8 @@ export function loadConfig(): NyxoraConfig {
       memory: { type: 'file', path: './memory.json' },
       web3: { rpc_urls: rpcUrls },
       integrations: {
-        telegram: { enabled: false }
+        telegram: { enabled: false },
+        discord: { enabled: false }
       }
     };
     
@@ -310,7 +319,9 @@ export function saveConfig(newConfig: NyxoraConfig): void {
     // Keys are no longer encrypted before saving. They are stored in plain text.
 
     const yamlStr = yaml.stringify(configToSave);
-    fs.writeFileSync(configPath, yamlStr, 'utf8');
+    const tempPath = configPath + '.tmp.' + Date.now();
+    fs.writeFileSync(tempPath, yamlStr, 'utf8');
+    fs.renameSync(tempPath, configPath);
   } catch (error) {
     console.error('Failed to save config.yaml', error);
   }

package/packages/core/src/gateway/chat.ts

@@ -49,13 +49,15 @@ export async function chatInteractive() {
     s.start('Thinking...');
 
     try {
-      const response = await fetch('http://localhost:3000/api/chat', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-nyxora-token': token,
-        },
-        body: JSON.stringify({ message: messageStr, session_id: 'cli-chat' })
+      // Use SSE streaming endpoint for real-time token output
+      const params = new URLSearchParams({
+        message: messageStr,
+        session_id: 'cli-chat',
+        token,
+      });
+
+      const response = await fetch(`http://localhost:3000/api/chat/stream?${params}`, {
+        headers: { 'x-nyxora-token': token },
       });
 
       if (!response.ok) {
@@ -69,14 +71,54 @@ export async function chatInteractive() {
         continue;
       }
 
-      const data = await response.json();
-      s.stop(pc.green('Nyxora:'));
-      
-      let finalReply = data.response || '';
-      // Strip <think> tags for clean UI
-      finalReply = finalReply.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
-      
-      console.log(finalReply + '\n');
+      let firstChunk = true;
+      let finalReply = '';
+
+      // Read SSE stream line by line
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+
+      if (reader) {
+        let buffer = '';
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+          for (const line of lines) {
+            if (!line.startsWith('data: ')) continue;
+            const raw = line.slice(6).trim();
+            if (raw === '[DONE]') break;
+            try {
+              const data = JSON.parse(raw);
+              if (data.progress) {
+                // Show tool progress on same line, overwriting previous
+                if (firstChunk) {
+                  s.stop(pc.cyan('Nyxora:'));
+                  firstChunk = false;
+                }
+                process.stdout.write(`\r${pc.italic(pc.gray(data.progress))}   `);
+              }
+              if (data.chunk) {
+                if (firstChunk) {
+                  s.stop(pc.green('Nyxora:'));
+                  process.stdout.write('\n');
+                  firstChunk = false;
+                }
+                // Clear progress line if any, then write chunk
+                finalReply += data.chunk;
+                process.stdout.write(data.chunk);
+              }
+            } catch {}
+          }
+        }
+      }
+
+      // Newline after streaming completes
+      if (!firstChunk) process.stdout.write('\n\n');
+
+
 
       // Check for pending transactions
       try {

package/packages/core/src/gateway/cli.ts

@@ -3,6 +3,10 @@
 import { initSafeLogger } from '../utils/safeLogger';
 initSafeLogger();
 
+import dns from 'dns';
+// Fix Node 18+ native fetch randomly failing on dual-stack VPS (IPv6 issues)
+dns.setDefaultResultOrder('ipv4first');
+
 import fs from 'fs';
 import path from 'path';
 import os from 'os';

package/packages/core/src/gateway/discordAdapter.ts

@@ -0,0 +1,87 @@
+import { Client, GatewayIntentBits, Message, TextChannel } from 'discord.js';
+import { processUserInput } from '../agent/reasoning';
+import { loadConfig } from '../config/parser';
+
+let discordClient: Client | null = null;
+
+export function startDiscordBot() {
+  const config = loadConfig();
+  const token = config.integrations?.discord?.bot_token;
+
+  if (!token || !config.integrations?.discord?.enabled) {
+    console.log('[Discord] Bot is disabled or missing bot_token in config.yaml.');
+    return;
+  }
+
+  discordClient = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+    ],
+  });
+
+  discordClient.once('ready', () => {
+    console.log(`🤖 Discord Bot is online and logged in as ${discordClient?.user?.tag}`);
+  });
+
+  discordClient.on('messageCreate', async (message: Message) => {
+    // Ignore messages from bots
+    if (message.author.bot) return;
+
+    // Check if the bot is mentioned
+    if (discordClient?.user && message.mentions.has(discordClient.user)) {
+      // Strip the mention from the message
+      const prompt = message.content.replace(new RegExp(`<@!?${discordClient.user.id}>`, 'g'), '').trim();
+      
+      if (!prompt) return;
+
+      console.log(`[Discord] Received mention from ${message.author.username} in #${(message.channel as TextChannel).name}: ${prompt}`);
+
+      // Send initial thinking indicator
+      let replyMessage: Message | null = null;
+      try {
+        replyMessage = await message.reply('⏳ *Thinking...*');
+      } catch (err) {
+        console.error('[Discord] Failed to send initial reply', err);
+        return;
+      }
+
+      const onProgress = async (progressText: string) => {
+        try {
+          if (replyMessage) {
+            await replyMessage.edit(`*${progressText}*`);
+          }
+        } catch (err) {
+          // Ignore minor edit errors
+        }
+      };
+
+      try {
+        const sessionId = `discord_${message.author.id}`;
+        const response = await processUserInput(prompt, 'user', onProgress, sessionId);
+        
+        // Clean up thought blocks if any
+        let finalResponse = response.replace(/<thought>[\s\S]*?<\/thought>\n?/g, '').replace(/<think>[\s\S]*?<\/think>\n?/g, '');
+        
+        if (replyMessage) {
+            // Discord has a 2000 character limit per message
+            if (finalResponse.length > 2000) {
+                await replyMessage.edit(finalResponse.slice(0, 1997) + '...');
+            } else {
+                await replyMessage.edit(finalResponse);
+            }
+        }
+      } catch (error: any) {
+        console.error('[Discord] Error processing message:', error);
+        if (replyMessage) {
+          await replyMessage.edit('❌ Sorry, I encountered an error while processing your request.');
+        }
+      }
+    }
+  });
+
+  discordClient.login(token).catch(err => {
+    console.error('[Discord] Failed to login:', err);
+  });
+}

package/packages/core/src/gateway/googleAuthModule.ts

@@ -7,7 +7,9 @@ const FALLBACK_TOKEN_PATH = getPath('google-tokens.json');
 
 const SCOPES = [
   'https://www.googleapis.com/auth/gmail.readonly',
+  'https://www.googleapis.com/auth/gmail.send',
   'https://www.googleapis.com/auth/calendar.readonly',
+  'https://www.googleapis.com/auth/calendar.events',
   'https://www.googleapis.com/auth/documents.readonly',
   'https://www.googleapis.com/auth/spreadsheets',
   'https://www.googleapis.com/auth/forms.responses.readonly',

package/packages/core/src/gateway/server.ts

@@ -27,7 +27,7 @@ import { validateToken, getSessionToken } from '../utils/state';
 import { initWebSocket } from './WebSocketManager';
 import fs from 'fs';
 import yaml from 'yaml';
-import { processUserInput, logger } from '../agent/reasoning';
+import { processUserInput, processUserInputStream, logger } from '../agent/reasoning';
 import { loadConfig, saveConfig, loadRpcConfig, saveRpcConfig } from '../config/parser';
 import { loadDefiKeys, saveDefiKeys } from '../config/defiConfigManager';
 import { loadMarketKeys, saveMarketKeys } from '../config/marketConfigManager';
@@ -52,6 +52,7 @@ import { executeCustomTx } from '../web3/skills/customTx';
 import { executeApprove, executeAaveSupply, executeVaultDeposit, executeUniv3Mint } from '../web3/skills/executeDefi';
 import { executeRevokeApproval } from '../web3/skills/revokeApprovals';
 import { startTelegramBot } from './telegram';
+import { startDiscordBot } from './discordAdapter';
 import { startBridgeWatcher } from '../agent/bridgeWatcher';
 import { eventListener } from '../web3/eventListener';
 import { formatTransactionSuccess, formatTransactionError } from '../utils/formatter';
@@ -60,17 +61,20 @@ import { generatePrivacyPolicyHtml, generateTosHtml } from './legalGenerator';
 import { episodicDB } from '../memory/episodic';
 import { ReflectionEngine } from '../memory/reflection';
 
-import { honchoDaemon } from '../agent/honchoDaemon';
+import { nyxDaemon } from '../agent/nyxDaemon';
 
 // Initialize Google Auth
 initGoogleAuth();
 
-// Start Background Honcho Daemon
-honchoDaemon.start();
+// Start Background Nyx Daemon
+nyxDaemon.start();
 
 // Synchronize all active skills to config.yaml on startup
 syncAllSkillsToConfig();
 
+// Start messaging adapters
+startDiscordBot();
+
 import util from 'util';
 
 // Intercept console.log and console.error
@@ -129,7 +133,7 @@ app.use('/api', (req, res, next) => {
     return next();
   }
 
-  const token = req.headers['x-nyxora-token'] as string;
+  const token = (req.headers['x-nyxora-token'] as string) || (req.query.token as string);
   const validation = validateToken(token);
   
   if (!validation.valid) {
@@ -198,7 +202,9 @@ app.post('/api/upload-google-credentials', (req, res) => {
     // The format needs to wrap it in "web" or "installed"
     const finalPayload = credentials.client_id ? { installed: credentials } : credentials;
     
-    fs.writeFileSync(credsPath, JSON.stringify(finalPayload, null, 2));
+    const tempPath = credsPath + '.tmp.' + Date.now();
+    fs.writeFileSync(tempPath, JSON.stringify(finalPayload, null, 2));
+    fs.renameSync(tempPath, credsPath);
     
     // Re-initialize google auth module
     initGoogleAuth();
@@ -672,7 +678,7 @@ app.post('/api/transactions/:id/approve', async (req, res) => {
     res.json({ success: true, status: 'processing', message: 'Transaction submitted to background processing.' });
 
     // Execute in background
-    (async () => {
+    const txPromise = (async () => {
       try {
         let result = '';
         if (tx.type === 'transfer') {
@@ -744,6 +750,8 @@ app.post('/api/transactions/:id/approve', async (req, res) => {
         logger.addEntry({ role: 'assistant', content: `❌ **Transaction Failed**\n\n${err.message}` }, sessionId);
       }
     })();
+    
+    txManager.trackPromise(txPromise);
   } catch (err: any) {
     txManager.updateStatus(req.params.id, 'failed', err.message);
     res.status(500).json({ error: err.message });
@@ -1049,7 +1057,51 @@ app.post('/api/chat', async (req, res) => {
   }
 });
 
-// --- Memory API Endpoints ---
+// --- Streaming Chat Endpoint (SSE) ---
+// Sends LLM tokens to the client as they arrive via Server-Sent Events.
+// The old /api/chat endpoint remains untouched for backward compatibility.
+app.get('/api/chat/stream', async (req, res) => {
+  const { message, session_id } = req.query as Record<string, string>;
+  if (!message) {
+    res.status(400).json({ error: 'Message is required' });
+    return;
+  }
+
+  // Setup SSE headers
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('X-Accel-Buffering', 'no'); // Disable Nginx buffering
+  res.flushHeaders();
+
+  const sendEvent = (data: object) => {
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+  };
+
+  const onChunk = (text: string) => sendEvent({ chunk: text });
+  const onProgress = (msg: string) => sendEvent({ progress: msg });
+
+  try {
+    await processUserInputStream(message, onChunk, onProgress, session_id);
+    // Trigger memory mechanisms after response completes
+    resetIdleTimer(session_id);
+    messageCounter++;
+    if (messageCounter >= 5) {
+      messageCounter = 0;
+      ReflectionEngine.runReflection(session_id).then(() => {
+        const { PromotionEngine } = require('../memory/promotionEngine');
+        PromotionEngine.runPromotionAndDecay();
+      }).catch(console.error);
+    }
+  } catch (err: any) {
+    sendEvent({ error: err.message });
+  } finally {
+    res.write('data: [DONE]\n\n');
+    res.end();
+  }
+});
+
+
 app.get('/api/memory', (req, res) => {
   try {
     const memories = episodicDB.getMemories();
@@ -1062,9 +1114,10 @@ app.get('/api/memory', (req, res) => {
 app.delete('/api/memory/all', (req, res) => {
   try {
     episodicDB.clearAllMemories();
+    episodicDB.clearAllPersonas();
     const { PromotionEngine } = require('../memory/promotionEngine');
     PromotionEngine.runPromotionAndDecay();
-    res.json({ success: true, message: "Episodic memory wiped completely." });
+    res.json({ success: true, message: "Episodic memory and persona traits wiped completely." });
   } catch (error: any) {
     res.status(500).json({ error: error.message });
   }
@@ -1241,11 +1294,14 @@ export async function startServer() {
   });
 
   let isShuttingDown = false;
-  const gracefulShutdown = () => {
+  const gracefulShutdown = async () => {
     if (isShuttingDown) return;
     isShuttingDown = true;
     console.log('[Nyxora Gateway] Received shutdown signal. Closing server...');
     
+    // Wait for active transactions
+    await txManager.waitForAll(10000);
+    
     if (server.closeAllConnections) {
       server.closeAllConnections();
     }

package/packages/core/src/gateway/setup-ml.ts

@@ -0,0 +1,68 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import pc from 'picocolors';
+import { spinner, note, outro } from '@clack/prompts';
+
+const appDir = path.join(os.homedir(), '.nyxora');
+const mlEngineDir = path.join(appDir, 'ml-engine');
+const venvDir = path.join(mlEngineDir, 'venv');
+const sourceReqPath = path.join(process.cwd(), 'packages', 'ml-engine', 'requirements.txt');
+
+function runCommand(command: string, args: string[], cwd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: 'ignore' });
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Command ${command} ${args.join(' ')} failed with code ${code}`));
+    });
+    child.on('error', reject);
+  });
+}
+
+export async function setupMlEngine() {
+  console.log(pc.cyan('\n⚙️  Initializing Universal Python ML Engine...\n'));
+  const s = spinner();
+  
+  try {
+    if (!fs.existsSync(mlEngineDir)) {
+      fs.mkdirSync(mlEngineDir, { recursive: true });
+    }
+
+    s.start('Creating Python Virtual Environment (venv)...');
+    if (!fs.existsSync(venvDir)) {
+      await runCommand('python3', ['-m', 'venv', venvDir], mlEngineDir);
+    }
+    s.stop(pc.green('Virtual Environment created successfully.'));
+
+    s.start('Installing heavy Data Science & AI dependencies (this may take a while)...');
+    const pipPath = path.join(venvDir, 'bin', 'pip');
+    
+    // Upgrade pip
+    await runCommand(pipPath, ['install', '--upgrade', 'pip'], mlEngineDir);
+    
+    // Install requirements
+    if (fs.existsSync(sourceReqPath)) {
+      await runCommand(pipPath, ['install', '-r', sourceReqPath], mlEngineDir);
+      s.stop(pc.green('Dependencies installed successfully.'));
+    } else {
+      s.stop(pc.yellow('requirements.txt not found. Skipping dependency installation.'));
+    }
+
+    note(
+      'The Python Sidecar is ready.\nIt will automatically start in the background when you run `nyxora start`.',
+      'ML Engine Configured'
+    );
+    
+  } catch (error: any) {
+    s.stop(pc.red('Failed to setup ML Engine.'));
+    console.error(pc.red(`Error: ${error.message}`));
+    console.log(pc.yellow('\nPlease ensure python3 and python3-venv are installed on your system.'));
+  }
+}
+
+// Allow running directly
+if (require.main === module) {
+  setupMlEngine().then(() => process.exit(0));
+}

package/packages/core/src/gateway/setup.ts

@@ -25,6 +25,28 @@ export async function runSetupWizard() {
   console.log(pc.cyan(logo));
   intro(pc.inverse(' Nyxora CLI Setup '));
 
+  try {
+    const nodeVersion = parseInt(process.versions.node.split('.')[0], 10);
+    if (nodeVersion < 18) {
+      console.error(pc.red(`\n❌ Unsupported Node.js version. Nyxora requires Node.js 18 or higher. You are running v${process.versions.node}`));
+      process.exit(1);
+    }
+    
+    const { execSync } = require('child_process');
+    const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+    const pyVersionStr = execSync(`${pythonCmd} -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    const [major, minor] = pyVersionStr.split('.').map(Number);
+    
+    if (major < 3 || (major === 3 && minor < 10)) {
+       console.error(pc.red(`\n❌ Unsupported Python version. Nyxora ML Engine requires Python 3.10+. You are running v${pyVersionStr}`));
+       process.exit(1);
+    }
+    note(`Node.js: v${process.versions.node}\nPython: v${pyVersionStr}`, 'System Requirements Met');
+  } catch (error) {
+    console.error(pc.red(`\n❌ Python 3 is not installed or not in your PATH. Nyxora requires Python 3.10+ for the ML Engine.`));
+    process.exit(1);
+  }
+
   const appDir = getAppDir();
   const config = loadConfig();
 
@@ -32,8 +54,8 @@ export async function runSetupWizard() {
 `Nyxora is a Web3 Assistant that operates with full access under your control.
 
 Critical Precautions:
-- Your Private Key is the lifeblood of your assets. NEVER copy or share the keystore.json file.
-- Any instructions you provide via Telegram or Dashboard can trigger on-chain transactions.
+- Your Private Key is the lifeblood of your assets. NEVER copy or share your vault.key file or OS Keyring password.
+- Any instructions you provide via Telegram, Discord, or the Dashboard can trigger on-chain transactions.
 - It is recommended to use a smart AI model for maximum accuracy.
 
 By using Nyxora, you retain full control over your own keys.`;
@@ -311,6 +333,7 @@ Provider: ${config.llm.provider}`;
     message: '💬 Select Integration Channels to enable:',
     options: [
       { value: 'telegram', label: 'Telegram Bot', hint: 'Requires Token' },
+      { value: 'discord', label: 'Discord Bot', hint: 'Requires Token' },
       { value: 'dashboard', label: 'Local Web Dashboard', hint: 'enabled by default' },
     ],
     initialValues: ['dashboard'],
@@ -417,6 +440,15 @@ Provider: ${config.llm.provider}`;
     }
   }
 
+  const setupDiscord = activeChannels.includes('discord');
+  let discordToken = '';
+  if (setupDiscord) {
+    discordToken = (await password({
+      message: 'Enter Discord Bot Token (Leave empty if already set):',
+    })) as string;
+    if (isCancel(discordToken)) return process.exit(0);
+  }
+
 
 
   // --- SAVING ---
@@ -470,6 +502,12 @@ Provider: ${config.llm.provider}`;
     delete config.integrations.telegram.authorized_chat_id;
   }
 
+  if (!config.integrations.discord) config.integrations.discord = { enabled: false };
+  config.integrations.discord.enabled = setupDiscord as boolean;
+  if (setupDiscord && discordToken) {
+    config.integrations.discord.bot_token = discordToken as string;
+  }
+
   saveConfig(config);
 
 
@@ -527,7 +565,7 @@ Provider: ${config.llm.provider}`;
     getBalance: 'get_balance',
     getMyAddress: 'get_my_address',
     checkPortfolio: 'check_portfolio',
-    getPrice: 'get_price',
+    getPrice: 'get_price_and_fiat_value',
     marketAnalysis: 'analyze_market',
     getTxHistory: 'get_tx_history',
     checkSecurity: 'check_token_security',