nyxora 26.6.7 → 26.6.9

package/.dockerignore

@@ -10,3 +10,12 @@ build
 .nyxora
 vault.key
 api_vault.key
+keystore.json
+memory.json
+memory.db*
+credentials.json
+google-*.json
+*.token
+config.yaml
+custom_tokens.json
+dynamic_tokens.json

package/CHANGELOG.md

@@ -5,7 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepashangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [26.6.7] - Unreleased
+## [26.6.9] - 2026-06-08
+### Security & UX Hardening
+- **Zero-Trust Auto-Lock (Passwordless)**: Implemented a robust idle timeout mechanism in the React Dashboard with an elegant glassmorphism blur overlay. The dashboard securely locks after periods of inactivity, requiring the user to authorize unlock directly via the CLI (`nyxora unlock`) to prevent unauthorized local access.
+- **Approval Replay Protection (Nonce Guard)**: Hardened the `transactionManager` to cryptographically sign all pending transaction payloads with a randomized 16-byte Nonce. The `/api/transactions/:id/approve` endpoint now strictly enforces Nonce matching and immediately marks it as `used_` upon first validation, completely eliminating double-spending and Replay Attack vectors.
+- **Graceful Shutdown (SQLite WAL Guard)**: Integrated deep `SIGTERM` and `SIGINT` signal listeners within the Gateway server. When the daemon is halted, the system now safely terminates active incoming requests and explicitly invokes `logger.close()` to securely flush SQLite Write-Ahead Logs (WAL) before exiting, completely eliminating the risk of database corruption.
+- **Resilient UI (Reconnect Overlay)**: Engineered a global network interceptor inside the Dashboard's React `apiFetch` utility. If the daemon goes offline unexpectedly or is restarting, the UI instantly pauses and deploys a transparent, pulsing "Nyxora Daemon Offline" screen. Once the daemon is revived, the overlay automatically lifts, preserving the user's workflow seamlessly.
+
+### Architecture & Production Readiness
+- **Dynamic Port Anti-Collision**: Replaced the hardcoded `3001` Policy Server port with a dynamic `process.env.POLICY_PORT` fallback. All Web3 Agents (Bridge, Swap, Transfer, etc.) are now dynamically linked to this environment variable, completely eliminating `ECONNREFUSED` crashes when port 3001 is occupied by other local developer applications.
+- **Production-Ready Path Resolution**: Eliminated hardcoded `process.cwd()` dependencies across the Gateway, Dashboard, and Plugin Manager. The CLI now utilizes robust absolute `__dirname` and `getAppDir()` traversal, guaranteeing the Dashboard UI and External Skills load flawlessly regardless of where the global CLI command is executed from.
+
+
+## [26.6.8] - 2026-06-08
+### Enterprise Features & Web3 Enhancements
+- **Zero-Downtime Directory Migration**: Restructured the root `~/.nyxora` local data directory into a strict `config/`, `data/`, `auth/`, and `run/` subdirectory architecture. Implemented a Lazy Auto-Migration Engine (`getPath()`) that seamlessly relocates legacy files to their new secure zones instantly upon access, ensuring zero-downtime and zero-data-loss upgrades for existing users.
+### Security & UX Updates
+- **Proactive Anti-Crash Engine**: Implemented `Max Retry` & `Exponential Backoff` auto-respawn logic inside the Monorepo Launcher. The daemon now features robust global `unhandledRejection` and `uncaughtException` guards across the Core, Policy, and Signer subsystems, ensuring sporadic Web3 network timeouts can no longer crash the main reasoning engine.
+- **Death Loop Telegram Alerts**: Integrated a critical emergency monitoring system into the Launcher. If a core microservice crashes catastrophically (5 times within 1 minute), the daemon will autonomously initiate an emergency lock-down to protect the system state and immediately broadcast a high-priority alert directly to the administrator's Telegram.
+- **Unix Socket Anti-EADDRINUSE Guard**: Implemented aggressive pre-flight cleanup routines for the `nyxora-signer.sock` IPC channel. The system now guarantees secure file unlinking before rebinding, eliminating recurring `EADDRINUSE` daemon failures upon rapid restart commands.
+
+### Bug Fixes & Optimizations
+- **NPM Package Optimization**: Added `assets/` to `.npmignore` to exclude large architectural diagrams and images from the NPM registry tarball, reducing the total package download size by over 11 MB.
+- **Docker Multi-Stage Build**: Radically refactored `Dockerfile` to a Multi-Stage architecture. The production image now exclusively installs runtime dependencies (`--omit=dev`) and leaves behind heavy build tools (`python3`, `make`, `g++`), dramatically shrinking the final container image size.
+- **Docker Security Patch**: Hardened `.dockerignore` to explicitly block local keystores (`keystore.json`), persistent memory (`memory.db`), and local credentials from accidentally leaking into Docker image layers during local builds.
+
+## [26.6.7] - 2026-06-07
 ### Enterprise Features & Web3 Enhancements
 - **Enterprise Portfolio Scanner**: Integrated a fully decentralized, real-time Dashboard UI (Nord Theme) to scan all native and ERC-20 token balances across 8 EVM chains natively, without relying on centralized third-party APIs.
 - **Real-Time USD Valuation**: Integrated DexScreener API into the Portfolio Scanner backend to actively compute and display USD portfolio values in real-time. Features an adaptive 2-minute memory cache system to ensure complete immunity against API rate-limits and eliminate LLM token consumption.
@@ -121,8 +146,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Fast CLI Shortcuts**: Added the `nyxora set-key <provider> <key>` global command shortcut allowing developers to quickly inject or override any API Key (OpenAI, Gemini, OpenRouter, Tavily, Brave) directly into the secure vault without traversing the wizard.
 
 ### AI Engine Optimizations
-- **Hybrid API Vault (Security)**: API Keys are no longer stored in plain text inside `config.yaml`. Nyxora now encrypts and stores them via `@napi-rs/keyring` utilizing OS-native credential management. For Headless/VPS Linux environments lacking DBUS/Secret Service, it automatically falls back to an isolated `api_vault.key` with strict `0600` permissions.
-- **Root-Level Config Auto-Migration**: Restructured `config.yaml` to move all API keys out of the nested `llm.credentials` into a logical, root-level `credentials` object. Implemented a silent auto-migration routine in `parser.ts` that safely upgrades legacy config files on boot without breaking existing setups.
+
 - **Web Search Smart Memory Cache**: Embedded a local Memory Cache (`Map`) into the `searchWeb` skill with a 5-minute (300,000ms) TTL. Exact duplicate queries now execute in 0ms and consume 0 API quota, dramatically improving conversation flow.
 - **Deep Research Mode**: The `search_web` tool definition now accepts a dynamic `depth` parameter (1 to 3). If users instruct the AI to conduct comprehensive research, Nyxora will automatically trigger `advanced` API payloads and extract up to 15 top web snippets simultaneously.
 - **Strict Skill Prioritization**: Added CRITICAL RULE 7 to the core NLP System Prompt. The AI is now hard-coded to prioritize native Web3 Skills (e.g. `get_price`, `analyze_market`, `check_security`) for all crypto-related queries, using `search_web` exclusively as a fallback mechanism.

package/README.md

@@ -10,7 +10,7 @@
 
 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. 
 
-**Nyxora now natively supports the Model Context Protocol (MCP)**. You can transform your external AI agents (like Claude Desktop and Cursor) into secure Web3 actors that execute swaps and fetch balances using Nyxora's secure signer vault. [View the MCP Integration Guide](https://nyxoraAI.github.io/Nyxora/guide/mcp-integration)
+**Nyxora now natively supports the Model Context Protocol (MCP)**. You can transform your external AI agents (like Claude Desktop and Cursor) into secure Web3 actors that execute swaps and fetch balances using Nyxora's secure signer vault. [View the MCP Integration Guide](https://nyxoraai.github.io/Nyxora/guide/mcp-integration)
 
 It operates under an institutional-grade **Cryptographically Bound Human-in-the-Loop** execution model, ensuring that Remote AIs (LLMs) never have unilateral access to your funds.
 
@@ -20,10 +20,10 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 
 ### Advanced Security Architecture
 *   **3-Tier IPC Architecture**: Nyxora is split into isolated processes: **Core** (LLM Runtime), **Policy Engine** (Guardrails on port 3001), and **Signer Vault** (Isolated Key Manager on Unix Sockets).
-*   **Cryptographically Bound Approval**: Policy changes and transactions requested by the AI are drafted as hashes (`sha256`). Approval via the UI requires a challenge nonce, preventing Man-in-the-Middle (MITM) attacks.
+*   **Approval Replay Protection (Nonce Guard)**: Transactions requested by the AI are drafted as hashes and signed with a randomized 16-byte Nonce. The `/api/transactions/:id/approve` endpoint strictly enforces Nonce matching to completely eliminate double-spending and Replay Attacks.
 *   **Immutable Policy Guardrails**: Transaction limits (e.g. `max_usd_per_tx`) are strictly enforced by the Policy Engine. The LLM has zero write-access to bypass these rules.
 *   **Plugin Sandbox VM**: Execute community-built external skills securely inside an airtight Node.js `vm` chamber with zero access to your file system or terminal processes.
-*   **Enterprise-Grade Stability**: Runs on a WAL-enabled SQLite backend with resilient anti-zombie connection timeouts to ensure maximum concurrency without database locks.
+*   **Graceful SQLite WAL Shutdown**: Integrated `SIGTERM`/`SIGINT` interceptors ensure that when the daemon stops, active requests are safely terminated and SQLite Write-Ahead Logs (WAL) are securely flushed, preventing database corruption.
 
 ### 🌐 Web3 Skills (On-Chain)
 *   **Security Scanner**: Nyxora can scan smart contracts via GoPlus Labs to detect Honeypots, Hidden Taxes, and malicious proxy upgrades before you buy.
@@ -39,8 +39,9 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 *   **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."*
 
 ### 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.
+*   **Resilient UI (Reconnect Overlay)**: Built-in global network interceptors ensure that if the daemon restarts or crashes, the UI immediately pauses with a transparent "Offline" overlay and seamlessly resumes your workflow once revived.
 *   **Zero-Click Multi-Session**: Instantly create isolated chat sessions with smart auto-naming triggered by your first prompt, exactly like ChatGPT.
-*   **Dynamic Trending Tokens**: Live top 5 crypto assets feed directly injected into the dashboard, completely clickable for instant AI market analysis.
 *   **Premium Utility-Centric UI**: A sleek, dark-themed dashboard built for high readability and professional Web3 execution, featuring Pseudo-Generative UI widgets (`<BalanceWidget>`, `<MarketWidget>`, `<SwapWidget>`).
 *   **Massive 2026 Model Roster**: Out-of-the-box support for cutting-edge models via Google Gemini, OpenAI, Groq, Mistral, xAI, DeepSeek, OpenRouter, and local Ollama, equipped with a searchable CLI prompt to instantly find your favorite model.
 *   **Strict NLP Exactness (Rule 8)**: The AI is rigorously instructed never to hallucinate or guess missing transaction parameters (like destination chains or swap amounts). It halts and requests human clarification, guaranteeing 100% precision.
@@ -66,7 +67,7 @@ The following diagram illustrates Nyxora's **3-Tier Monorepo Architecture**, sho
 
 ## 🛡️ Advanced Security & Threat Model
 
-To dive deeper into the technical details of our Zero-Knowledge security architecture, please visit the [Nyxora Security Blueprint](https://nyxoraAI.github.io/Nyxora/).
+To dive deeper into the technical details of our Zero-Knowledge security architecture, please visit the [Nyxora Security Blueprint](https://nyxoraai.github.io/Nyxora/).
 
 ---
 
@@ -93,16 +94,23 @@ Alternatively, you can install it manually on any operating system using NPM:
 npm install -g nyxora@latest
 ```
 
-# 2. Run the Interactive Setup Wizard (API Keys, Wallet, Telegram)
+### 2. Run the Interactive Setup Wizard (API Keys, Wallet, Telegram)
+```bash
 nyxora setup
+```
 
-# 3. Start the Nyxora background daemon
+### 3. Start the Nyxora background daemon
+```bash
 nyxora start
+```
 
-# 4. Open the Web Dashboard
+### 4. Open the Web Dashboard
+```bash
 nyxora dashboard
+```
 
-# Utility: Atomically clear the AI's short-term and long-term memory
+### Utility: Atomically clear the AI's short-term and long-term memory
+```bash
 nyxora clear --force
 ```
 > **⚠️ IMPORTANT:** Whenever you re-run `nyxora setup` or manually edit the config files, you **must restart the daemon** by running `nyxora restart` for the changes to take effect.
@@ -135,7 +143,7 @@ npm start
 
 For complete technical deep-dives into our Cryptographic Architecture, please visit our official VitePress Documentation Site!
 
-> **🔗 [Read the Full Nyxora Documentation Here](https://nyxoraAI.github.io/Nyxora/)**
+> **🔗 [Read the Full Nyxora Documentation Here](https://nyxoraai.github.io/Nyxora/)**
 
 *(Includes guides on Secure Wallet Imports, Architecture Blueprints, Troubleshooting, and Custom Skill Development).*
 

package/SECURITY.md

@@ -38,7 +38,9 @@ Nyxora completely eliminates the need for manual "Master Passwords" or custom AE
 When the background daemon boots via `nyxora start`, the Signer Vault process reads the Private Key directly from the OS Keyring without requiring human intervention. This ensures the daemon can safely persist across reboots while maintaining institutional-grade encryption at rest.
 
 ### Secure Fallback Storage
-In headless server environments (e.g., VPS, Docker) where a GUI Keyring is unavailable, Nyxora gracefully falls back to a strictly permissioned `.env` / `vault.key` file mechanism. This file is programmatically enforced with `chmod 0600` permissions (Read/Write for owner only), preventing access by other system users.
+In headless server environments (e.g., VPS, Docker) where a GUI Keyring is unavailable, Nyxora gracefully falls back to a strictly permissioned `vault.key` file mechanism. This file is programmatically enforced with `chmod 0600` permissions (Read/Write for owner only), preventing access by other system users.
+
+> **Note:** This OS-level keyring protection is strictly reserved for your Web3 Wallet Private Keys. Standard integration credentials (like LLM API Keys or Telegram tokens) are managed separately via the `config.yaml` file for transparent developer access.
 
 ---
 
@@ -64,12 +66,22 @@ approval_hash = sha256(policy_diff + timestamp + user_id)
 ```
 This ensures that what the human saw on the UI matches exactly what is being executed, preventing the LLM from secretly modifying the payload in transit.
 
-### Anti-Replay Challenge Nonce
-Every approval UI prompt utilizes a **Single-Use Challenge Nonce** with a strict expiry time. This mitigates *XSS Token Leaks* and *Replay Attacks*, ensuring that an old approval token cannot be stolen and reused for a malicious transaction later.
+### Anti-Replay Challenge Nonce (Nonce Guard)
+Every approval UI prompt utilizes a **Single-Use Challenge Nonce** (a randomized 16-byte cryptographic string). The `transactionManager` signs all pending payloads with this Nonce. The `/api/transactions/:id/approve` endpoint strictly enforces matching and immediately marks the Nonce as `used_` upon first validation. This completely eliminates *XSS Token Leaks*, *Double-Spending*, and *Replay Attacks*, ensuring that an old approval token cannot be stolen and reused for a malicious transaction later.
+
+---
+
+## 4. Physical Access & Data Integrity
+
+### Zero-Trust Auto-Lock (Physical Protection)
+To protect against unauthorized physical access (e.g., leaving a laptop unattended), the Dashboard implements a **Zero-Trust Auto-Lock** mechanism. After a period of inactivity, the UI aggressively blurs and locks all state. Unlocking the interface requires the user to execute `nyxora unlock` directly from the host operating system's CLI. This guarantees that anyone physically sitting at the unlocked dashboard cannot execute transactions without also possessing SSH or direct terminal access to the host machine.
+
+### SQLite WAL Graceful Shutdown (Data Integrity)
+To prevent database corruption during abrupt terminations, the Gateway daemon employs deep `SIGTERM` and `SIGINT` interceptors. When a halt is requested, the system safely terminates active incoming API requests and explicitly flushes the SQLite Write-Ahead Logs (WAL) before fully exiting, ensuring enterprise-grade state stability.
 
 ---
 
-## 4. Plugin Sandboxing (Node.js VM Isolation)
+## 5. Plugin Sandboxing (Node.js VM Isolation)
 
 Community plugins and custom skills are NEVER executed directly at the OS level. Instead, Nyxora creates an airtight **Virtual Machine (VM) Sandbox** in memory. 
 

package/bin/nyxora.mjs

@@ -11,9 +11,9 @@ const __dirname = path.dirname(__filename);
 const projectRoot = path.join(__dirname, '..');
 
 const appDir = path.join(os.homedir(), '.nyxora');
-const pidFile = path.join(appDir, 'daemon.pid');
-const logFile = path.join(appDir, 'gateway.log');
-const tokenFile = path.join(appDir, 'auth.token');
+const pidFile = path.join(appDir, 'run', 'daemon.pid');
+const logFile = path.join(appDir, 'run', 'gateway.log');
+const tokenFile = path.join(appDir, 'auth', 'auth.token');
 
 if (!fs.existsSync(appDir)) {
   fs.mkdirSync(appDir, { recursive: true });
@@ -117,7 +117,13 @@ async function dashboard() {
   }
 
   if (fs.existsSync(tokenFile)) {
-    const token = fs.readFileSync(tokenFile, 'utf8').trim();
+    let token = fs.readFileSync(tokenFile, 'utf8').trim();
+    if (token.startsWith('{')) {
+      try {
+        const parsed = JSON.parse(token);
+        token = parsed.token;
+      } catch (e) {}
+    }
     const url = `http://localhost:3000?token=${token}`;
     console.log(`Opening Dashboard at ${url}`);
     try {
@@ -275,8 +281,38 @@ async function runDoctor() {
   await new Promise(resolve => child.on('close', resolve));
 }
 
+async function unlock() {
+  if (fs.existsSync(tokenFile)) {
+    let token = fs.readFileSync(tokenFile, 'utf8').trim();
+    if (token.startsWith('{')) {
+      try {
+        const parsed = JSON.parse(token);
+        token = parsed.token;
+      } catch (e) {}
+    }
+    try {
+      const fetch = (await import('node-fetch')).default;
+      const res = await fetch('http://localhost:3000/api/status/unlock', {
+        method: 'POST',
+        headers: {
+          'x-nyxora-token': token
+        }
+      });
+      if (res.ok) {
+        console.log('✅ Dashboard unlocked successfully.');
+      } else {
+        console.log('❌ Failed to unlock dashboard. Is the daemon running?');
+      }
+    } catch (e) {
+      console.log('❌ Failed to communicate with the daemon. Is it running?');
+    }
+  } else {
+    console.log('❌ Authentication token not found.');
+  }
+}
+
 async function main() {
-  switch (command) {
+  switch(command) {
     case 'doctor': await runDoctor(); break;
     case 'setup': await setup(); break;
     case 'clear': await clearMemory(process.argv.slice(3)); break;
@@ -286,6 +322,7 @@ async function main() {
     case 'stop': await stop(); break;
     case 'restart': await restart(); break;
     case 'dashboard': await dashboard(); break;
+    case 'unlock': await unlock(); break;
     case 'clean-logs': await cleanLogs(); break;
     case 'autostart': await autostart(process.argv[3]); break;
     case '-v':
@@ -307,6 +344,7 @@ Commands:
   restart        Restart the daemon
   setup          Run the interactive Setup Wizard
   dashboard      Open the dashboard in your browser
+  unlock         Unlock an inactive dashboard session
   doctor         Run system diagnostics and check requirements
   clear          Atomically clear the AI's short/long-term memory SQLite database
   clean-logs     Clear the daemon logs

package/dist/launcher.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const safeLogger_1 = require("./packages/core/src/utils/safeLogger");
+(0, safeLogger_1.initSafeLogger)();
+const child_process_1 = require("child_process");
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const INTERNAL_AUTH_TOKEN = crypto_1.default.randomBytes(64).toString('hex');
+console.log(`[Launcher] Generated Internal Auth Token: ${INTERNAL_AUTH_TOKEN.substring(0, 8)}...`);
+const nyxoraDir = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora');
+const authDir = path_1.default.join(nyxoraDir, 'auth');
+if (!fs_1.default.existsSync(authDir))
+    fs_1.default.mkdirSync(authDir, { recursive: true, mode: 0o700 });
+const tokenPath = path_1.default.join(authDir, 'runtime.token');
+fs_1.default.writeFileSync(tokenPath, INTERNAL_AUTH_TOKEN, { mode: 0o600 });
+console.log(`[Launcher] Secured runtime token at ${tokenPath} (0600)`);
+const env = {
+    ...process.env,
+    INTERNAL_AUTH_TOKEN,
+    SIGNER_SOCKET_PATH: '/tmp/nyxora-signer.sock',
+    TS_NODE_CACHE: 'false'
+};
+const spawnService = (name, command, args, env, inheritStdio = false) => {
+    let child;
+    let crashCount = 0;
+    let crashWindowStart = Date.now();
+    let isShuttingDown = false;
+    const startProcess = () => {
+        child = (0, child_process_1.spawn)(command, args, { env, stdio: inheritStdio ? 'inherit' : 'pipe' });
+        if (!inheritStdio) {
+            child.stdout?.on('data', (data) => process.stdout.write(`[${name}] ${data}`));
+            child.stderr?.on('data', (data) => process.stderr.write(`[${name}] ERROR: ${data}`));
+        }
+        child.on('close', async (code) => {
+            console.log(`[${name}] Exited with code ${code}`);
+            if (isShuttingDown)
+                return;
+            const now = Date.now();
+            if (now - crashWindowStart > 60000) {
+                crashCount = 0;
+                crashWindowStart = now;
+            }
+            crashCount++;
+            if (crashCount > 5) {
+                console.error(`[Launcher] FATAL: ${name} crashed 5 times in 1 minute. Initiating emergency shutdown.`);
+                isShuttingDown = true;
+                try {
+                    const yaml = require('yaml');
+                    const configPath = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'config', 'config.yaml');
+                    // Fallback check just in case it hasn't migrated yet
+                    const actualConfigPath = fs_1.default.existsSync(configPath) ? configPath : path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'config.yaml');
+                    if (fs_1.default.existsSync(actualConfigPath)) {
+                        const configStr = fs_1.default.readFileSync(actualConfigPath, 'utf8');
+                        const config = yaml.parse(configStr);
+                        const tgToken = config?.telegram?.bot_token;
+                        const tgChatId = config?.telegram?.admin_chat_id;
+                        if (tgToken && tgChatId) {
+                            const alertText = config?.alerts?.emergency_text || "🚨 FATAL ERROR: A critical process has crashed repeatedly. Nyxora is executing an emergency auto-shutdown to protect your system. Please check the server logs.";
+                            await fetch(`https://api.telegram.org/bot${tgToken}/sendMessage`, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ chat_id: tgChatId, text: alertText })
+                            }).catch(() => { });
+                        }
+                    }
+                }
+                catch (e) { }
+                process.exit(1);
+                return;
+            }
+            console.log(`[Launcher] Restarting ${name} in 3 seconds... (Attempt ${crashCount}/5)`);
+            setTimeout(startProcess, 3000);
+        });
+    };
+    startProcess();
+    return {
+        kill: () => {
+            isShuttingDown = true;
+            if (child && !child.killed && child.pid) {
+                try {
+                    process.kill(child.pid, 'SIGTERM');
+                }
+                catch (e) { }
+            }
+        }
+    };
+};
+console.log('[Launcher] Starting Monorepo Services...');
+const socketPath = env.SIGNER_SOCKET_PATH;
+if (fs_1.default.existsSync(socketPath)) {
+    console.log(`[Launcher] Removing stale unix socket at ${socketPath}`);
+    fs_1.default.unlinkSync(socketPath);
+}
+const children = [];
+const isCompiled = __filename.endsWith('.js');
+const ext = isCompiled ? '.js' : '.ts';
+const cmd = isCompiled ? 'node' : 'npx';
+const baseArgs = isCompiled ? [] : ['ts-node', '-T'];
+const signerPath = path_1.default.join(__dirname, `packages/signer/src/server${ext}`);
+const signer = spawnService('Signer', cmd, [...baseArgs, signerPath], env);
+children.push(signer);
+setTimeout(() => {
+    const policyPath = path_1.default.join(__dirname, `packages/policy/src/server${ext}`);
+    const policy = spawnService('Policy', cmd, [...baseArgs, policyPath], env);
+    children.push(policy);
+    setTimeout(() => {
+        const corePath = path_1.default.join(__dirname, `packages/core/src/gateway/cli${ext}`);
+        const args = process.argv.slice(2);
+        const core = spawnService('Core', cmd, [...baseArgs, corePath, ...args], env, true);
+        children.push(core);
+    }, 1000);
+}, 1000);
+// Ensure all child processes are killed when launcher exits
+let isCleaningUp = false;
+const cleanup = () => {
+    if (isCleaningUp)
+        return;
+    isCleaningUp = true;
+    console.log('\n[Launcher] Shutting down all services...');
+    children.forEach(c => c.kill());
+    // Give them a moment to cleanup
+    setTimeout(() => {
+        try {
+            require('child_process').execSync('pkill -f ts-node');
+        }
+        catch (e) { }
+        process.exit(0);
+    }, 1000);
+};
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);
+process.on('SIGTERM', cleanup);
+process.on('exit', cleanup);

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

@@ -40,7 +40,6 @@ const pluginManager_1 = require("../system/pluginManager");
 const paths_1 = require("../config/paths");
 const picocolors_1 = __importDefault(require("picocolors"));
 exports.logger = new logger_1.Logger();
-let currentKeyIndex = 0;
 const PROVIDER_CONFIGS = {
     ollama: { baseURL: process.env.OLLAMA_BASE_URL ? `${process.env.OLLAMA_BASE_URL}/v1` : 'http://localhost:11434/v1', requiresApiKey: false },
     gemini: { baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/', requiresApiKey: true },
@@ -59,27 +58,12 @@ async function getOpenAI() {
     let apiKey = 'local';
     if (providerConf.requiresApiKey) {
         apiKey = '';
-        let configuredKeys = config.llm.api_keys;
-        if (typeof configuredKeys === 'string') {
-            configuredKeys = [configuredKeys];
-        }
-        if (Array.isArray(configuredKeys) && configuredKeys.length > 0) {
-            const keys = configuredKeys.filter(k => typeof k === 'string' && k.trim() !== '');
-            if (keys.length > 0) {
-                currentKeyIndex = currentKeyIndex % keys.length;
-                apiKey = keys[currentKeyIndex];
-                console.log(`[LLM] Using rotated API Key (${currentKeyIndex + 1}/${keys.length}): ${apiKey.substring(0, 4)}...`);
-                currentKeyIndex++;
-            }
-        }
+        const keyName = `${providerName}_key`;
+        apiKey = vaultKeys[keyName] || config.credentials?.[keyName] || '';
         if (!apiKey) {
-            const fallbackKeyName = `${providerName}_key`;
-            apiKey = vaultKeys[fallbackKeyName] || config.credentials?.[fallbackKeyName] || '';
-            if (!apiKey) {
-                throw new Error(`No API Key found for ${providerName}. Please run 'nyxora setup' to configure it.`);
-            }
-            console.log(`[LLM] Using API Key from secure vault`);
+            throw new Error(`[Security] No API Key found for ${providerName} in OS Keyring. Please run 'nyxora set-key ${providerName} <key>' or 'nyxora setup'.`);
         }
+        console.log(`[LLM] Using API Key securely unlocked from OS Keyring vault.`);
     }
     return new openai_1.OpenAI({
         baseURL: providerConf.baseURL,
@@ -130,7 +114,7 @@ function getSystemPrompt() {
 You are equipped with a native wallet.
 The current real-world date and time is: ${currentDateTime}. Use this for any time-related questions.
 
-CRITICAL RULE 1: ADVANCED NLP & PERSONA. You must act as a highly intelligent, adaptive, and intuitive assistant (similar to ChatGPT or Gemini). You must seamlessly understand the user's language structure, including slang, shorthand, informal context, and mixed languages. However, you must maintain a professional and highly accurate Web3 operational standard.
+CRITICAL RULE 1: NEVER expose internal JSON tool calls to the user. Always parse them and explain the outcome naturally.
 CRITICAL RULE 2: STRICT LANGUAGE MATCHING. You MUST strictly reply in the exact same language as the user's LATEST prompt. If the user's latest prompt is in English, you MUST reply entirely in English, completely ignoring the language of previous messages. If their latest prompt is in Indonesian, reply in Indonesian.
 CRITICAL RULE 3: FORMATTING & CONCISENESS. 
   - Your responses MUST be concise and to the point. Do not add unnecessary fluff or overly long explanations unless explicitly asked.

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

@@ -9,6 +9,7 @@ class TransactionManager {
     transactions = new Map();
     createPendingTransaction(type, chainName, details) {
         const id = crypto_1.default.randomUUID();
+        const nonce = crypto_1.default.randomBytes(16).toString('hex');
         const tx = {
             id,
             type,
@@ -16,6 +17,7 @@ class TransactionManager {
             details,
             status: 'pending',
             createdAt: Date.now(),
+            nonce,
         };
         this.transactions.set(id, tx);
         return tx;

package/dist/packages/core/src/config/parser.js

@@ -11,38 +11,15 @@ const fs_1 = __importDefault(require("fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const paths_1 = require("./paths");
 async function loadApiKeys() {
-    const vaultPath = (0, paths_1.getPath)('api_vault.key');
-    try {
-        const { Entry } = require('@napi-rs/keyring');
-        const entry = new Entry('nyxora', 'api_keys');
-        const data = await entry.getPassword();
-        if (data)
-            return JSON.parse(data);
-    }
-    catch (e) {
-        if (fs_1.default.existsSync(vaultPath)) {
-            try {
-                const file = fs_1.default.readFileSync(vaultPath, 'utf8');
-                return JSON.parse(file);
-            }
-            catch (err) { }
-        }
-    }
-    return {};
+    const config = loadConfig();
+    return config.credentials || {};
 }
 async function saveApiKeys(newKeys) {
-    const vaultPath = (0, paths_1.getPath)('api_vault.key');
-    const currentKeys = await loadApiKeys();
-    const mergedKeys = { ...currentKeys, ...newKeys };
-    const dataString = JSON.stringify(mergedKeys);
-    try {
-        const { Entry } = require('@napi-rs/keyring');
-        const entry = new Entry('nyxora', 'api_keys');
-        await entry.setPassword(dataString);
-    }
-    catch (e) {
-        fs_1.default.writeFileSync(vaultPath, dataString, { mode: 0o600 });
-    }
+    const config = loadConfig();
+    if (!config.credentials)
+        config.credentials = {};
+    config.credentials = { ...config.credentials, ...newKeys };
+    saveConfig(config);
 }
 function loadConfig() {
     const configPath = (0, paths_1.getPath)('config.yaml');
@@ -74,21 +51,6 @@ function loadConfig() {
                 console.error('[Config] Failed to auto-migrate config file', e);
             }
         }
-        // Auto-migrate from config.yaml to Keyring/Vault
-        if (parsed.credentials && Object.keys(parsed.credentials).length > 0) {
-            const credsToMigrate = { ...parsed.credentials };
-            saveApiKeys(credsToMigrate).then(() => {
-                console.log('[Config] Auto-migrated API keys to secure vault.');
-                delete parsed.credentials;
-                try {
-                    const yamlStr = yaml_1.default.stringify(parsed);
-                    fs_1.default.writeFileSync(configPath, yamlStr, 'utf8');
-                }
-                catch (e) { }
-            }).catch(e => {
-                console.error('[Config] Failed to migrate API keys to secure vault', e);
-            });
-        }
         return {
             agent: parsed.agent || { name: 'Nyxora-Default', description: 'Your Personal Web3 Assistant.', default_chain: 'base', default_router: 'auto', default_slippage: 0.5 },
             llm: parsed.llm || {

package/dist/packages/core/src/config/paths.js

@@ -30,6 +30,44 @@ function getAppDir() {
     }
     return process.cwd();
 }
+function ensureDir(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+}
 function getPath(filename) {
-    return path_1.default.join(getAppDir(), filename);
+    const baseDir = getAppDir();
+    // Determine subdirectory based on filename
+    let subDir = '';
+    const lowerFile = filename.toLowerCase();
+    if (lowerFile.endsWith('.db') || lowerFile.endsWith('.db-wal') || lowerFile.endsWith('.db-shm') || lowerFile.endsWith('.json') && lowerFile.includes('memory') || lowerFile.endsWith('.md') || lowerFile.includes('orders')) {
+        subDir = 'data';
+    }
+    else if (lowerFile.endsWith('.yaml') || lowerFile.includes('config') || lowerFile.includes('skills') || lowerFile.includes('whitelist') || lowerFile.includes('tokens')) {
+        subDir = 'config';
+    }
+    else if (lowerFile.endsWith('.token') || lowerFile.includes('vault') || lowerFile.includes('credentials')) {
+        subDir = 'auth';
+    }
+    else if (lowerFile.endsWith('.log') || lowerFile.includes('pid')) {
+        subDir = 'run';
+    }
+    const targetDir = path_1.default.join(baseDir, subDir);
+    ensureDir(targetDir);
+    const fullPath = path_1.default.join(targetDir, filename);
+    // AUTO-MIGRATION: If file exists in root but not in subdir, move it
+    const oldRootPath = path_1.default.join(baseDir, filename);
+    if (subDir !== '') {
+        if (fs_1.default.existsSync(oldRootPath) && !fs_1.default.existsSync(fullPath)) {
+            try {
+                fs_1.default.renameSync(oldRootPath, fullPath);
+                console.log(`[Migration] Moved ${filename} to ${subDir}/ directory.`);
+            }
+            catch (err) {
+                console.warn(`[Migration] Failed to move ${filename} to ${subDir}/`, err);
+                return oldRootPath; // fallback to root if migration fails
+            }
+        }
+    }
+    return fullPath;
 }

package/dist/packages/core/src/gateway/cli.js

@@ -106,7 +106,7 @@ async function main() {
         };
         const mappedKey = keyMap[provider.toLowerCase()] || `${provider.toLowerCase()}_key`;
         await (0, parser_1.saveApiKeys)({ [mappedKey]: key });
-        console.log(picocolors_1.default.green(`✅ API Key for ${provider} saved securely to vault.`));
+        console.log(picocolors_1.default.green(`✅ API Key for ${provider} saved successfully.`));
         process.exit(0);
     }
     // Check for wallet command
@@ -146,9 +146,9 @@ async function main() {
     // 2. Setup boilerplate files if in global mode and they don't exist
     let isFirstBoot = false;
     if (isGlobalMode) {
-        const globalConfigPath = path_1.default.join(appDir, 'config.yaml');
-        const globalUserMdPath = path_1.default.join(appDir, 'user.md');
-        const globalIdentityMdPath = path_1.default.join(appDir, 'IDENTITY.md');
+        const globalConfigPath = (0, paths_1.getPath)('config.yaml');
+        const globalUserMdPath = (0, paths_1.getPath)('user.md');
+        const globalIdentityMdPath = (0, paths_1.getPath)('IDENTITY.md');
         // Copy default config.yaml
         if (!fs_1.default.existsSync(globalConfigPath)) {
             isFirstBoot = true;
@@ -157,7 +157,7 @@ async function main() {
                 fs_1.default.copyFileSync(exampleConfigPath, globalConfigPath);
             }
             else {
-                fs_1.default.writeFileSync(globalConfigPath, 'agent:\n  name: Nyxora-Agent\n  default_chain: base\nllm:\n  provider: openai\n  model: gpt-4o-mini\n  temperature: 0.2\n  api_keys: []\nmemory:\n  type: file\n  path: memory.json\n');
+                fs_1.default.writeFileSync(globalConfigPath, 'agent:\n  name: Nyxora-Agent\n  default_chain: base\nllm:\n  provider: openai\n  model: gpt-4\n  temperature: 0.7\nmemory:\n  type: file\n  path: memory.json\n');
             }
         }
         if (!fs_1.default.existsSync(globalUserMdPath)) {