nyxora 26.6.30 → 26.7.2

package/CHANGELOG.md

@@ -5,6 +5,40 @@ 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/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [26.7.2]
+### Orchestrator Architecture & Extensibility
+- **Multi-Turn Agentic Loop**: Radically overhauled the core LLM execution loop in `web3Agent.ts` and `osAgent.ts`. The engines now utilize a robust `while (turnCount < MAX_TURNS)` architecture. This definitively resolves the "lost context" bug where the AI would drop its tool schemas after a single execution turn, granting Nyxora the endurance to execute highly complex, multi-step operations (e.g., directory scanning followed by programmatic file generation) in a single uninterrupted stream.
+- **External Skill Builder (`SystemExternalPlugin`)**: Engineered a completely isolated IoC plugin dedicated solely to third-party integrations. Introduced the `create_agent_skill` tool, enabling the AI to programmatically scaffold new Node.js execution scripts (`execute.ts`) and auto-generate strict YAML frontmatter for `SKILL.md`. This transforms Nyxora into a fully autonomous Agent-Building Platform that can code and register its own tools dynamically without muddying the native OS/Web3 tool ecosystems.
+
+### Cognitive Reasoning & Identity Architecture
+- **Cognitive Reasoning Engine**: Implemented a powerful new Cognitive Skill system that parses user intent and routes them to strict Standard Operating Procedures (SOPs). Added `cognitiveManager.ts` and foundational SOPs for Systematic Debugging, Test-Driven Development (TDD), and Architecture Planning to drastically improve agent output reliability and strictly enforce developer disciplines.
+- **Episodic Memory V2 Architecture**: Completely overhauled the Episodic Memory SQLite database (`episodic.db`) to fix memory duplication and identity conflict issues (e.g., persona overlap).
+  - Added a `key_topic` deduplication layer to ensure old conflicting facts are automatically wiped before new ones are saved.
+  - Re-routed the `update_profile` AI tool to write directly to SQLite instead of `user.md`, fixing severe overwrite bugs caused by the background Promotion Engine.
+- **`forget_memory` Tool**: Introduced a surgical memory deletion skill. The AI can now autonomously search for and permanently delete specific habits or mistaken persona traits from the SQLite database upon the user's explicit request.
+
+### Architectural Revamps & UI/UX
+- **Settings Dashboard Redesign**: Restructured the Settings interface into a sleek, full-width Master-Detail layout with a dedicated sidebar. Consolidated all advanced configuration menus (Web3 Skills, OS Skills, RPC, DeFi, Oracles) previously scattered across the main navigation directly into this unified command center for a cleaner user experience.
+- **UI & Layout Optimizations**: Fixed restrictive width constraints on configuration panels, allowing them to fluidly span the entire viewport. Eliminated double-scrollbar bugs on embedded skill panels by seamlessly integrating them into the parent container with unified glassmorphism scrollbar styling.
+- **Zero-Latency Conversational Approval**: Completely overhauled the Web3 transaction approval flow. 
+  - Eradicated all intrusive UI modals (`PendingTransactions.tsx`) from the Dashboard and ripped out `InlineKeyboard` popup logic from the Telegram Gateway.
+  - Transactions are now approved organically via text. The AI autonomously interprets conversational cues (e.g., answering "Yes" or "No") and executes the pending on-chain transaction in the background using the new `confirmPendingTx` skill.
+  - **Token Efficiency Intact**: Ingeniously maintained the `fastReturnTools` bypass. Transaction preparation strings now output a direct prompt ("*Please reply with 'Yes' to execute, or 'No' to cancel*") instantly, achieving conversational UX without incurring the latency or API cost of generating an LLM prompt for every single transaction queue.
+- **Pre-flight Balance & Gas Security Check**: Engineered a universal `balanceChecker` utility that validates wallet balances across all 9 Web3 transaction skills *before* queuing them.
+  - Acts as a smart guardrail similar to Rabby Wallet's UX. It automatically aborts transaction preparations entirely if the user lacks the required ERC20 tokens or if their Native Coin (ETH/BNB) balance is completely depleted (preventing out-of-gas failures).
+  - **Human-Readable Error Feedback**: Overhauled the raw error outputs from 18-decimal Wei formats to standard units. The system now dynamically fetches token metadata (decimals and symbols) on-the-fly and applies `formatUnits` to present clean, readable error messages (e.g., *"You need at least 500 USDC"* instead of raw Wei integers), significantly reducing friction for novice users.
+
+## [26.7.1]
+### Bug Fixes & Optimizations
+- **Native Coin Resolution Mass Remediation**: Fixed a systemic architectural flaw where Web3 transaction modules strictly validated against the Zero Address (`0x00...00`) for native coins (ETH/BNB/MATIC). The codebase now universally intercepts and processes the `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee` pseudo-address generated by aggregators. This stabilizes critical transactional skills including:
+  - **DEX Swapping**: Prevents contract decimals parsing crashes during Native to ERC20 swaps (`swapToken.ts`).
+  - **Asset Transfers**: Safely bypasses `transfer()` contract calls when sending native coins (`transfer.ts`).
+  - **DeFi Lending**: Ensures AAVE dynamically routes to WETH gateways for native deposits (`defiLending.ts`).
+  - **Yield Vaults & Liquidity (V3)**: Secures deposit validations and prevents false rejections (`yieldVault.ts`, `provideLiquidity.ts`).
+  - **Security Approvals**: Blocks artificial revoke requests on native coins gracefully (`revokeApprovals.ts`).
+  - **Balance Queries**: Correctly routes to native balance RPC methods instead of standard ERC20 `balanceOf` (`getBalance.ts`).
+
+
 ## [26.6.30]
 ### UI/UX & Quality of Life
 - **AI Web Platform Style Empty State**: Overhauled the default chat interface when no messages are present. The dashboard now features a sleek, centered "What's on your mind today?" greeting, automatically repositioning the input bar to the center.
@@ -24,7 +58,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [26.6.29]
 ### Release & Stability
-- **Beta Phase**: Nyxora officially enters the stable Beta phase for wider public testing.
+- **Beta Phase (Reverted)**: Nyxora briefly entered the Beta phase here for wider public testing, but the status has since reverted to Alpha in `v26.7.2` to accommodate massive core architectural experiments.
 - **NPM Publishing Integrity**: Explicitly whitelisted `CHANGELOG.md` within the `package.json` files array to guarantee release notes are synchronized onto the public NPM registry.
 
 ## [26.6.28]

package/README.md

@@ -2,13 +2,14 @@
 **Your Personal Web3 Assistant.**
 
 
-[![Status: Beta](https://img.shields.io/badge/Status-Beta-green.svg)](#)
+[![Status: Alpha](https://img.shields.io/badge/Status-Alpha-orange.svg)](#)
 [![Built on Base](https://img.shields.io/badge/Built_on-Base-0052FF?style=flat&logo=base&logoColor=white)](https://base.org/)
 [![MCP Supported](https://img.shields.io/badge/MCP-Supported-blue.svg)](#)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Security: Defense-in-Depth](https://img.shields.io/badge/Security-Defense--in--Depth-blue.svg)](#️-advanced-security-threat-model)
 [![Execution: Cryptographic Approval](https://img.shields.io/badge/Execution-Cryptographic--Approval-orange.svg)](#️-advanced-security-threat-model)
 [![Privacy: Local-Only Keys](https://img.shields.io/badge/Privacy-Local--Only--Keys-success.svg)](#️-advanced-security-threat-model)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://makeapullrequest.com)
 
 Nyxora is a **secure, non-custodial runtime infrastructure for autonomous onchain agents** built with a robust Monorepo architecture (Node.js & React). Designed for autonomous workflows with a premium Utility-Centric dark-themed UI and strict client-side key isolation. 
 
@@ -94,12 +95,13 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 *   **System Automation & Full OS Access**: Instruct the agent to read/write local files, run terminal commands, and browse the web natively.
 *   **Automated Excel Reporting**: Instruct the agent to compile its Web3 portfolio or transaction history findings and autonomously generate beautiful `.xlsx` spreadsheet reports saved directly to your local machine.
 *   **Unstoppable Synergy**: Combine both engines with a single prompt. Example: *"Read the latest presale token email from my Gmail, automatically set a Take Profit limit order on Uniswap, and log the execution result to my Google Sheets."*
+*   **Autonomous Skill Synthesizing (`skillExtractor.ts`)**: Instruct the AI to learn a new workflow, and it will autonomously write the Node.js execution logic and schema, saving it locally as a custom skill following the **`agentskills.io`** standard!
 
 ### 🧠 The Masterpiece Memory Architecture
 *   **4-Layer Air-Gapped Vault**: Nyxora features a god-tier memory system that completely isolates conversational habits from the OS Keyring. The AI can dynamically learn your behaviors without ever having physical read-paths to your private keys.
 *   **Hard-Coded Anti-Injection Shield**: We enforce a Zero-Trust memory paradigm. Before any user habit is saved to the local SQLite database, it must pass a strict RegExp-based validation layer that autonomously annihilates Private Keys, BIP-39 Seed Phrases, and Prompt Injection attempts.
+*   **Dialectic User Modeling (Honcho Daemon)**: Nyxora continuously runs an asynchronous background daemon that quietly audits your conversational history. It extracts your behavioral traits, trading style, and risk tolerance, saving them securely to `episodic.db` and injecting them dynamically into the AI's reasoning engine.
 *   **Smart Suggestion Engine**: Nyxora actively queries its Layer-2 Episodic Database to seamlessly autocomplete your repetitive Web3 routines. If you always swap on Arbitrum using USDC, the AI will proactively suggest it, slashing human-in-the-loop latency by up to 90%.
-*   **Persistent Background Reflection**: Empowered by background idle timers and message-count thresholds, Nyxora quietly transcribes your habits into a permanent profile while you step away from the keyboard, ensuring it never forgets your identity even after daemon reboots.
 
 ### AI & UI Customization
 *   **Zero-Trust Auto-Lock (Passwordless)**: A sleek glassmorphism blur overlay automatically locks the dashboard during inactivity. Unlocking requires physical local execution via the CLI (`nyxora unlock`), preventing unauthorized local access.
@@ -213,6 +215,16 @@ By downloading, installing, or using the Nyxora AI Agent, you agree to our assum
 
 ---
 
+## 🤝 Contributing
+
+We welcome community contributions! Whether you want to fix a bug, improve documentation, or build a whole new Web3 Plugin, we'd love to have your help.
+
+Nyxora features an extensible **Plugin Architecture** that makes it incredibly easy to add new capabilities (like new DEXs, Oracles, or Chains) without modifying the core reasoning engine.
+
+> **📖 [Read the Contribution Guidelines](CONTRIBUTING.md)** to get started!
+
+---
+
 ## 📖 Official Documentation
 
 For complete technical deep-dives into our Cryptographic Architecture, please visit our official VitePress Documentation Site!

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

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.honchoDaemon = exports.HonchoDaemon = void 0;
+const parser_1 = require("../config/parser");
+const llmUtils_1 = require("../utils/llmUtils");
+const episodic_1 = require("../memory/episodic");
+const reasoning_1 = require("./reasoning");
+const picocolors_1 = __importDefault(require("picocolors"));
+class HonchoDaemon {
+    isRunning = false;
+    intervalId = null;
+    INTERVAL_MS = 60 * 60 * 1000; // Run every hour
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        // Initial run after 5 minutes
+        setTimeout(() => this.runAnalysis(), 5 * 60 * 1000);
+        // Scheduled runs
+        this.intervalId = setInterval(() => {
+            this.runAnalysis();
+        }, this.INTERVAL_MS);
+        console.log(picocolors_1.default.magenta('[Honcho] Dialectic User Modeling daemon started.'));
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+        }
+        this.isRunning = false;
+        console.log(picocolors_1.default.magenta('[Honcho] Daemon stopped.'));
+    }
+    async runAnalysis() {
+        console.log(picocolors_1.default.magenta('[Honcho] Running dialectic user modeling...'));
+        const sessions = reasoning_1.logger.getSessions();
+        if (sessions.length === 0)
+            return;
+        const allHistory = reasoning_1.logger.getHistory(undefined, 100); // Get recent 100 messages
+        if (allHistory.length < 5)
+            return; // Not enough context
+        const config = (0, parser_1.loadConfig)();
+        const prompt = `You are Honcho, Nyxora's background Persona Auditor.
+Your task is to analyze the user's recent chat history and extract long-term persona traits, preferences, or behavioral rules.
+Focus ONLY on facts about the user. (e.g. "User prefers high-risk trades", "User is a developer", "User wants concise answers", "User hates memecoins").
+
+Output your findings as a strict JSON array of strings. If nothing new is found, return [].
+Example: ["User avoids Ethereum mainnet due to gas", "User prefers dark mode"]
+
+Chat History:
+${allHistory.map((m) => `[${m.role}] ${m.content}`).join('\n')}
+`;
+        try {
+            const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
+                return await client.chat({
+                    model: config.llm.model,
+                    messages: [{ role: 'system', content: prompt }],
+                    temperature: 0.1
+                });
+            });
+            let content = response.message.content || '[]';
+            // Clean markdown if any
+            content = content.replace(/\`\`\`json/g, '').replace(/\`\`\`/g, '').trim();
+            let traits = [];
+            try {
+                const parsed = JSON.parse(content);
+                if (Array.isArray(parsed)) {
+                    traits = parsed;
+                }
+                else if (parsed.traits && Array.isArray(parsed.traits)) {
+                    traits = parsed.traits;
+                }
+            }
+            catch (e) {
+                console.error(picocolors_1.default.red('[Honcho] Failed to parse JSON traits'), content);
+            }
+            if (traits.length > 0) {
+                traits.forEach(trait => {
+                    episodic_1.episodicDB.updatePersonaTrait(trait, 0.8, 'honcho');
+                    console.log(picocolors_1.default.magenta(`[Honcho] Discovered new trait: ${trait}`));
+                });
+            }
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`[Honcho] Analysis failed: ${e.message}`));
+        }
+    }
+}
+exports.HonchoDaemon = HonchoDaemon;
+exports.honchoDaemon = new HonchoDaemon();

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

@@ -10,11 +10,36 @@ const logger_1 = require("../memory/logger");
 const tracker_1 = require("../gateway/tracker");
 const episodic_1 = require("../memory/episodic");
 const skillManager_1 = require("../utils/skillManager");
+const cognitiveManager_1 = require("../cognitive/cognitiveManager");
+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.
+Continue using tools until the task is completely finished and verified.
+</tool_persistence>
+
+<mandatory_tool_use>
+NEVER answer the following using only your internal memory — ALWAYS use the relevant tool:
+- Arithmetic, math, calculations
+- System State: OS version, RAM, processes
+- File contents, file sizes
+- Real-world current events
+</mandatory_tool_use>
+
+<act_dont_ask>
+When a user's request has a clear, standard interpretation, take immediate ACTION instead of asking for clarification.
+</act_dont_ask>
+
+<task_completion>
+The deliverable must be a working artifact backed by real tool output — not just a description or a plan of how you would do it.
+NEVER fabricate, hallucinate, or forge tool outputs.
+</task_completion>
+`;
 const registry_1 = require("../plugin/registry");
 const picocolors_1 = __importDefault(require("picocolors"));
 exports.logger = new logger_1.Logger();
 const llmUtils_1 = require("../utils/llmUtils");
-function getSystemPrompt(context = 'os') {
+function getSystemPrompt(context = 'os', userInput = '') {
     const config = (0, parser_1.loadConfig)();
     const currentDateTime = new Date().toLocaleString('en-US');
     let basePrompt = `You are Nyxora's OS Agent (System & Automation Specialist).
@@ -27,7 +52,15 @@ CRITICAL RULE 1: NEVER expose internal JSON tool calls. Explain the outcome natu
 CRITICAL RULE 2: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt.
 CRITICAL RULE 3: FILE SYSTEM SAFETY. You are STRICTLY FORBIDDEN from modifying config.yaml, rpc_key.yaml, or policy.yaml using terminal commands like sed or echo.
 CRITICAL RULE 4: CRON JOBS VS LIMIT ORDERS. Do NOT use schedule_task for price-based trading triggers. Use schedule_task for time-based recurring tasks.
-CRITICAL RULE 5: TOOL CONFIDENCE. NEVER fabricate file contents or command outputs.`;
+CRITICAL RULE 5: TOOL CONFIDENCE. NEVER fabricate file contents or command outputs.
+
+${EXECUTION_DISCIPLINE}
+`;
+    // Inject Active Cognitive Skills
+    const activeSOP = cognitiveManager_1.cognitiveManager.loadActiveCognitiveSkills(userInput);
+    if (activeSOP) {
+        basePrompt += `\n\n[ACTIVE COGNITIVE SKILLS]\n${activeSOP}\n`;
+    }
     // Inject Episodic Memories
     try {
         const recentMemories = episodic_1.episodicDB.getMemories().slice(0, 10);
@@ -56,30 +89,47 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
     const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
     const sanitizedHistory = sanitizeHistoryForLLM(history, activeTools, config.llm.provider);
     let messages = [
-        { role: 'system', content: getSystemPrompt('os') },
+        { role: 'system', content: getSystemPrompt('os', input) },
         ...sanitizedHistory
     ];
     try {
-        const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
-            return await client.chat({
-                model: config.llm.model,
-                temperature: config.llm.temperature,
-                messages: messages,
-                tools: activeTools
+        let turnCount = 0;
+        const MAX_TURNS = 10;
+        while (turnCount < MAX_TURNS) {
+            turnCount++;
+            const currentHistory = exports.logger.getHistory(sessionId);
+            const sanitizedHistory = sanitizeHistoryForLLM(currentHistory, activeTools, config.llm.provider);
+            const messages = [
+                { role: 'system', content: getSystemPrompt('os', input) },
+                ...sanitizedHistory
+            ];
+            const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
+                return await client.chat({
+                    model: config.llm.model,
+                    temperature: config.llm.temperature,
+                    messages: messages,
+                    tools: activeTools
+                });
             });
-        });
-        const responseMessage = response.message;
-        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) {
+            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, '');
+                finalContent = finalContent.trim();
+                return finalContent;
+            }
             let canFastReturnAll = true;
             let accumulatedResults = [];
             // Enabled fastReturnTools to eliminate 2nd LLM latency for transaction popups
@@ -97,7 +147,12 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                 if (onProgress)
                     onProgress(`_⚡ Running tool: ${toolName}..._`);
                 try {
-                    args = JSON.parse(toolCall.function.arguments);
+                    let argStr = toolCall.function.arguments;
+                    // [Auto-Recovery] Fix common LLM JSON errors (e.g. missing closing brace)
+                    if (argStr && !argStr.trim().endsWith('}')) {
+                        argStr += '}';
+                    }
+                    args = JSON.parse(argStr);
                 }
                 catch (parseError) {
                     console.error(picocolors_1.default.red(`[LLM Validation Error] Invalid JSON arguments for ${toolName}: ${parseError.message}`));
@@ -157,44 +212,11 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                 exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
                 return finalContent;
             }
-            // Second call to get the final answer after tool execution
-            const secondSanitized = sanitizeHistoryForLLM(exports.logger.getHistory(sessionId), activeTools, config.llm.provider);
-            const secondMessages = [
-                { role: 'system', content: getSystemPrompt('os') },
-                ...secondSanitized
-            ];
-            const secondResponse = await (0, llmUtils_1.executeWithRetry)(async (client) => {
-                return await client.chat({
-                    model: config.llm.model,
-                    messages: secondMessages,
-                });
-            });
-            if (secondResponse.usage?.total_tokens) {
-                tracker_1.Tracker.addTokens(secondResponse.usage.total_tokens, config.llm.provider);
-            }
-            tracker_1.Tracker.addEvent('llm.final_response', { provider: config.llm.provider });
-            let finalContent = secondResponse.message.content || "";
-            // Clean up orphaned <think> blocks that forgot to output </think>
-            finalContent = finalContent.replace(/<thought>[\s\S]*?<\/thought>\n?/gi, '');
-            finalContent = finalContent.replace(/<think>[\s\S]*?<\/think>\n?/gi, '');
-            if (finalContent.includes('<think>')) {
-                finalContent = finalContent.replace(/<think>[\s\S]*?\n\n/i, '');
-                finalContent = finalContent.replace(/<think>[\s\S]*$/i, '');
-            }
-            finalContent = finalContent.trim();
-            exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
-            return finalContent;
-        }
-        let finalContent = responseMessage.content || "No response generated.";
-        // Clean up orphaned <think> blocks that forgot to output </think>
-        finalContent = finalContent.replace(/<thought>[\s\S]*?<\/thought>\n?/gi, '');
-        finalContent = finalContent.replace(/<think>[\s\S]*?<\/think>\n?/gi, '');
-        if (finalContent.includes('<think>')) {
-            finalContent = finalContent.replace(/<think>[\s\S]*?\n\n/i, '');
-            finalContent = finalContent.replace(/<think>[\s\S]*$/i, '');
+            // Loop continues, sending tool results in the next turn
         }
-        finalContent = finalContent.trim();
-        return finalContent;
+        const maxTurnMsg = "⚠️ Reached maximum interaction limit (10 turns). Please be more specific.";
+        exports.logger.addEntry({ role: 'assistant', content: maxTurnMsg }, sessionId);
+        return maxTurnMsg;
     }
     catch (error) {
         console.error("LLM Error:", error);

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

@@ -135,15 +135,25 @@ Do NOT perform any web3 tasks or generic answers until they provide all 4 detail
     // V3: Inject Personalized Risk Profile
     try {
         const profile = exports.logger.getUserProfile();
-        if (profile) {
+        const personas = episodic_1.episodicDB.getPersonas();
+        if (profile || personas.length > 0) {
             basePrompt += `\n\n--- [USER_PERSONA] RISK PROFILE & PREFERENCES ---\n`;
-            basePrompt += `Risk Level: ${profile.risk_level}\n`;
-            basePrompt += `Max Slippage Tolerance: ${profile.max_slippage}%\n`;
-            basePrompt += `Avoid Memecoins: ${profile.avoid_memecoins ? 'YES' : 'NO'}\n`;
-            if (profile.custom_rules) {
-                basePrompt += `Custom Rules: ${profile.custom_rules}\n`;
+            if (profile) {
+                basePrompt += `Risk Level: ${profile.risk_level}\n`;
+                basePrompt += `Max Slippage Tolerance: ${profile.max_slippage}%\n`;
+                basePrompt += `Avoid Memecoins: ${profile.avoid_memecoins ? 'YES' : 'NO'}\n`;
+                if (profile.custom_rules) {
+                    basePrompt += `Custom Rules: ${profile.custom_rules}\n`;
+                }
+                basePrompt += `CRITICAL: You MUST adhere to these risk parameters when advising the user or executing tools. If a requested action violates these parameters (e.g., buying a high-risk memecoin when 'Avoid Memecoins' is YES), you MUST warn the user and refuse execution unless they explicitly override.\n`;
+            }
+            if (personas.length > 0) {
+                basePrompt += `\nObserved Traits (Dialectic Modeling):\n`;
+                personas.forEach(p => {
+                    basePrompt += `- ${p.trait} (Confidence: ${(p.confidence * 100).toFixed(0)}%)\n`;
+                });
+                basePrompt += `Adapt your tone, vocabulary, and suggestions to align with these observed user traits.\n`;
             }
-            basePrompt += `CRITICAL: You MUST adhere to these risk parameters when advising the user or executing tools. If a requested action violates these parameters (e.g., buying a high-risk memecoin when 'Avoid Memecoins' is YES), you MUST warn the user and refuse execution unless they explicitly override.\n`;
         }
     }
     catch { }
@@ -161,14 +171,15 @@ async function processUserInput(input, role = 'user', onProgress, sessionId) {
         .map(m => ({ role: m.role === 'system' ? 'user' : m.role, content: m.content || "" }));
     const routerPrompt = `You are Nyxora's Semantic Intent Router. Your job is to classify the user's FINAL message into one of three categories: 'web3', 'os', or 'general'.
 Rules:
-1. FOCUS ONLY ON THE FINAL MESSAGE. History is only for resolving pronouns (e.g., "buy it").
-2. If the final message involves blockchain, crypto, bridging, swapping, tokens, or wallets, reply 'web3'.
-3. If the final message involves fetching news, web search, weather, email, files, or terminal, reply 'os'.
-4. If it's just casual conversation, reply 'general'.
-Reply with EXACTLY ONE WORD.`;
+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 (e.g., 'tf', 'wd', 'buy', 'sell'). Translate their core intent logically.
+3. If the core intent involves blockchain, crypto, bridging, swapping, trading, sending/receiving, tokens, wallets, or transactions, reply 'web3'.
+4. If the core intent involves OS automation, web search, weather, emails, files, terminal, or changing AI settings, reply 'os'.
+5. If it is purely casual conversation, chit-chat, or greetings, reply 'general'.
+Reply with EXACTLY ONE WORD: web3, os, or general.`;
     const routerMessages = [
         { role: 'system', content: routerPrompt },
-        ...textOnlyHistory.slice(-4),
+        ...textOnlyHistory.slice(-10),
         { role: 'user', content: input }
     ];
     let context = 'general';
@@ -178,7 +189,7 @@ Reply with EXACTLY ONE WORD.`;
                 model: config.llm.model,
                 messages: routerMessages,
                 temperature: 0.1,
-                max_tokens: 10
+                max_tokens: 1000
             });
         }, 3); // 3 retries for transient 503/429 errors
         let contextResponse = (routerResponse.message.content || 'general').toLowerCase().trim();

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

@@ -1,28 +1,25 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateProfileToolDefinition = void 0;
 exports.updateProfile = updateProfile;
-const fs_1 = __importDefault(require("fs"));
-const paths_1 = require("../config/paths");
-function updateProfile(content, mode) {
+const episodic_1 = require("../memory/episodic");
+const promotionEngine_1 = require("../memory/promotionEngine");
+async function updateProfile(content, mode) {
     try {
-        const userMdPath = (0, paths_1.getPath)('user.md');
         if (mode === 'replace') {
-            fs_1.default.writeFileSync(userMdPath, content, 'utf8');
-            return "Profile replaced successfully. New user.md has been saved.";
+            episodic_1.episodicDB.clearAllMemories();
         }
-        else {
-            let existingContent = "";
-            if (fs_1.default.existsSync(userMdPath)) {
-                existingContent = fs_1.default.readFileSync(userMdPath, 'utf8');
+        const lines = content.split('\n').filter(l => l.trim() !== '');
+        for (const line of lines) {
+            let cleanLine = line.trim();
+            if (cleanLine.startsWith('- '))
+                cleanLine = cleanLine.substring(2);
+            if (cleanLine) {
+                episodic_1.episodicDB.addCandidateFact(cleanLine, 1.0, 'general', 'permanent');
             }
-            const newContent = existingContent + "\n" + content;
-            fs_1.default.writeFileSync(userMdPath, newContent, 'utf8');
-            return "Profile appended successfully. New instructions added to user.md.";
         }
+        await promotionEngine_1.PromotionEngine.runPromotionAndDecay();
+        return "Profile updated successfully in Episodic DB and synchronized to user.md.";
     }
     catch (error) {
         return `Failed to update profile: ${error.message}`;