nyxora 26.7.10 → 26.7.23

package/CHANGELOG.md

@@ -2,7 +2,181 @@
 
 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/),
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [26.7.23]
+### Dashboard Features & UI
+- **System & Maintenance Module**: Engineered the `System.tsx` component from scratch. The interface now features a sleek, edge-to-edge stacked row list design, completely abandoning the legacy card-based layout for a more professional, native application feel.
+- **Native System Operations**: Implemented deep integration between the React frontend and the Node.js daemon. Users can now natively trigger **Restart Server**, **Shutdown Server**, and **Clear System Cache** directly from the UI without touching the CLI.
+- **OS Autostart Controller**: Introduced a cross-platform Auto-Start toggle in the dashboard. The system dynamically queries and manages `.desktop` (Linux) and `.plist` (macOS) configurations via `GET/POST /api/system/autostart`.
+- **Wallet Balances Fix**: Resolved a data mapping issue in `Wallets.tsx`. The component now correctly utilizes `viem`'s `formatUnits` combined with backend `decimals` and `priceUsd` to flawlessly compute and render real-time fiat values for multi-chain assets. Added a functional Refresh button to sync the latest portfolio states.
+- **Minimalist Aesthetic**: Purged redundant icons/emojis across the System settings to achieve a clean, text-heavy minimalist aesthetic, reserving visual icons strictly for the page header and footer.
+
+### Bug Fixes & Agent Enhancements
+- **Windows CLI Spawn Fix (Critical)**: Resolved a major UX issue for global Windows users where running `nyxora start` would rapidly spawn multiple visible `cmd.exe` and `node.exe` console windows. Implemented `windowsHide: true` across all detached daemon spawns and Cloudflared sub-processes in `nyxora.mjs` and `launcher.ts`, ensuring Nyxora boots perfectly in headless mode on Windows without spamming the user's desktop.
+- **Windows CLI Stop/Restart Fix**: Fixed a critical crash where `nyxora stop` and `nyxora restart` failed on Windows systems. Switched process termination from POSIX-only `-pid` (Process Group Signal) to native Windows `taskkill /pid <PID> /t /f` via `spawnSync`, ensuring all daemon and microservice child processes (like Python ML Engine) are cleanly forcefully terminated without leaving zombie processes.
+- **Smart Anti-Loop Breaker V2.0**: Completely overhauled the agent's anti-loop safety mechanism. Removed rigid hard-limits on specific tool usage (e.g. `write_local_file`) to allow unconstrained complex coding sessions. Replaced it with an intelligent "Soft Warning" system that injects a self-reflection prompt into the LLM's context every 5 repetitions, allowing the AI to organically realize if it's hallucinating and ask the user for help. Also increased global `MAX_TURNS` from 30 to 50 for extended autonomous workflows.
+- **Auto-Scroll Chat Snap Fix**: Resolved a Dashboard UI glitch where LLM text streaming would scroll the container to the top instead of the bottom. Fixed ResizeObserver spacer calculation timing and exact layout recalculation bounds, ensuring smooth and flawless chat autoscrolling identical to the Desktop app.
+## [26.7.22]
+### Bug Fixes & Monorepo Enhancements
+- **Global `npm install` Crash Fix (Critical Fix)**: Resolved a severe issue where `nyxora start` would crash immediately after global installation (`npm install -g nyxora`) due to missing dependencies. All required workspace dependencies (e.g., `systeminformation`, messaging bot SDKs) have now been synced and hoisted to the root `package.json`, ensuring the background daemon can boot properly for global users without throwing `Cannot find module` errors.
+- **Dependency Overrides Synchronization**: Fixed dependency conflict warnings during installation by aligning `lodash-es` and `undici` versions with the root workspace `overrides`.
+
+## [26.7.21]
+### Dashboard Features & UI
+- **Control Panel Expansion**: Engineered 4 brand new native dashboard menus (`Memory`, `Security`, `Wallets`, `Workflows`) transforming the dashboard into a full-fledged agent control panel.
+- **Backend API Integration**: Fully connected the new UI to real-time Nyxora Core APIs. The interface now dynamically fetches and manages state for episodic memory (`/api/memory`), security policies (`/api/policy`), EVM wallet and multi-chain portfolio (`/api/wallet`, `/api/portfolio`), and automated playbooks (`/api/playbooks`).
+- **Global Localization**: Ensured all new dashboard components are strictly in English to support the global user base natively.
+- **Design System Consistency**: Applied the modern, unified `overview-container` styling across all new pages, featuring consistent glassmorphism effects, responsive card grids, and proper token alignments. Unified the toggle switch design in `Workflows.tsx` to match the custom iOS-style pill toggle used across other menus (e.g., `Skills.tsx`).
+- **Playbook Editor (CRUD)**: Implemented full CRUD capabilities in the Workflows menu. Users can now directly create, edit, toggle, and delete scenarios via an integrated Markdown editor modal, with automatic local saving to `~/.nyxora/playbooks/`.
+- **Memory Document RAG Upload**: Upgraded the Memory UI with a document upload feature. Connected the Node.js gateway to Python ML Engine's new `/memory/document` RAG endpoint, allowing seamless PDF/TXT/MD file chunking and vectorization using `pypdf`.
+- **Wallet Security Enhancement**: Completely removed the raw Private Key display and toggle component from the Wallets UI to ensure maximum operational security.
+- **Bug Fix**: Resolved a critical render crash in `Workflows.tsx` caused by a missing lucide-react import (`RefreshCw`), and cleaned up obsolete Episodic Memory fetch logic from the Logs menu.
+
+### AI Memory & RAG Engine
+- **Native Document Ingestion**: Introduced a new `/document` endpoint in the Python ML Engine. The system now autonomously parses, chunks, and vectorizes user-uploaded documents (PDF, TXT, MD) utilizing Langchain (`PyPDFLoader`, `RecursiveCharacterTextSplitter`).
+- **Episodic Memory Sync**: Ingested document chunks are strictly categorized as `DOCUMENT` and seamlessly synchronized into both the SQLite episodic database and the local ChromaDB vector store for instant RAG retrieval.
+
+### Desktop & Dashboard UI
+- **Sidebar State Fix**: Resolved a visual bug in the SvelteKit Desktop app where active chat sessions remained highlighted even while the global Search modal was open.
+- **Dashboard Cleanup**: Removed deprecated components (e.g., `DefiKeys.tsx`) and optimized settings panels across the React dashboard.
+
+## [26.7.20]
+### Desktop App MVP: UI/UX & Architecture Overhaul
+- **Premium Interface Scaling**: Completely redesigned the Settings modal dimensions for desktop viewing. Expanded the modal wrapper to `w-[92vw]` with a maximum width of `1400px`, and removed legacy mobile constraints (`max-w-3xl`) from all submenu components (Agent Profile, LLM Engine, etc.) to utilize the full horizontal workspace natively.
+- **Scroll Hierarchy Fixes**: Resolved a severe UX issue where scrolling inside long submenus (like Playbooks) would scroll the entire modal out of view. Enforced a strict height constraint (`h-[72vh]`) and `min-h-0` on inner containers, allowing localized, independent scrolling within the content pane.
+- **Svelte 5 Reactivity Migration**: Refactored legacy Svelte 4 `<svelte:component>` dynamic imports within `SettingsModal.svelte`. Replaced them with modern Svelte 5 `{@const}` tags to eliminate compile-time deprecation warnings and ensure full compatibility with the new Runes architecture.
+- **Asset Pipeline Synchronization**: Fixed pervasive `404 Not Found` errors for network/router icons (1inch, LiFi, CoinGecko, 0x) in the Desktop app by properly synchronizing the `public/routers/` directory from the Dashboard into the Desktop's `static/routers/` distribution folder.
+
+### Desktop App MVP: Core Features Porting
+- **Voice Mode & File Upload**: Successfully ported Dashboard Web features to the SvelteKit Desktop app. The chat composer now fully supports **Voice Mode** (via Web Speech API for TTS/STT) and **File Upload** (document analysis via `/api/upload`).
+- **Advanced Risk Policies**: Integrated missing risk settings into the Desktop `Risk & Policy` menu, including **Daily Spend Limit**, **Strictly Avoid Memecoins** toggle, and **Allowed Contracts Whitelist**.
+- **Auto-Lock Session (Idle Timeout)**: Added global idle timeout protection to the Desktop app. Users can configure auto-lock (15, 30, or 60 minutes) in `Security & Privacy`. Once locked, a glassmorphism overlay blocks the UI until authorized via the terminal (`nyxora unlock`).
+
+### Desktop Bug Fixes & Semantic Alignment
+- **Settings Auto-Save Illusion (Critical Fix)**: Fixed a severe UX logic flaw where settings were retained in memory even if the user cancelled/closed the modal. Introduced an explicit **Save Configuration** and **Cancel** button mechanism. The settings modal now safely fetches a fresh configuration state from the backend upon closing, guaranteeing that unsaved edits are flawlessly discarded.
+- **Semantic Text Refinement**: Updated Desktop wording in the Security tab from "Dashboard Access" to "App Access" to accurately reflect the native application environment.
+
+### Frontend Architecture & Core Refactoring
+- **SvelteKit Migration (Desktop)**: Overhauled the native desktop interface by migrating from React to SvelteKit. Unified the component design system under `packages/desktop/src/lib/components`.
+- **State Management**: Upgraded from React hooks to native Svelte Stores (`stores/app.ts`, `stores/wallet.ts`) for seamless state propagation.
+- **Core Integrations**: Updated `osAgent.ts`, `llmProvider.ts`, and `logger.ts` to seamlessly plug into the new architectural layout.
+
+## [26.7.19]
+### Web3 & Market Intelligence
+- **Super-Report & AI Financial Advisor**: Merged GoPlus Security data directly into the `analyze_market` tool to eliminate duplicate API requests. The LLM now receives a comprehensive dataset including Liquidity, 24h Volume, Pool Age, Holder Concentration (real-time from GoPlus), and smart contract security status (Honeypot, Taxes) in a single unified execution.
+- **Advisor Persona Nudge**: Injected a "Sharp Crypto Financial Advisor" persona into the LLM's system note. The AI is now instructed to actively evaluate the combined fundamental and security metrics to provide concrete, strategic recommendations (e.g., Quick Flip, Hold, DCA, Avoid) rather than just passively reciting numbers.
+
+### Agent Intelligence & Context Engine
+- **Gen-AI Execution & Discipline Upgrade**: Completely overhauled `promptBuilder.ts` by injecting advanced cognitive discipline instructions (including *Execution Bias* and *Output Directives*). The AI is now significantly more proactive in utilizing tools, highly resilient to failures (*varies strategy* instead of giving up), and responds with a strict, senior-developer brevity (*anti-loop*, *anti-repetition*).
+- **Date/Time Context Optimization**: Removed deprecated instructions that forced the LLM to execute a terminal command to check the current time. The system datetime context is now dynamically injected during prompt building, allowing the AI to read it instantly from memory. This saves unnecessary tool calls and reduces API quota consumption.
+
+### Architecture & Memory Unification
+- **Memory Fragmentation Cleanup**: Resolved a cross-language memory storage architectural conflict. Previously, the Node.js core wrote explicit preferences to `.nyxora/data/user.md` while the Python ML Engine wrote inferred narrative memories to `.nyxora/memory/USER.md`, creating severe overwrite risks on case-insensitive operating systems (Windows/Mac).
+- **ML Engine Refactor**: Modified Python endpoints to exclusively read and write to the `data` directory. AI-generated narrative files have been systematically renamed to `narrative_user.md` and `narrative_memory.md` to cleanly separate them from explicit user profiles.
+- **LLM Prompt Header Clarification**: Updated memory injection headers in the Node.js `system prompt` to be strictly descriptive (`EXPLICIT USER PREFERENCES` vs `AI INFERRED USER NARRATIVE`), eliminating LLM context confusion.
+
+### Bug Fixes & Stability
+- **Tool Loop Limit Expansion**: Increased the `MAX_TURNS` threshold in `osAgent.ts` from 10 to 30. This empowers the agent to autonomously execute significantly longer chained processes and complex coding refactors without being prematurely interrupted by system limits.
+- **System Nudge UI Leak Remediation**: Prevented internal error logs from leaking into the user interface. When the LLM hallucinates or enters a prolonged *Silent Stop* that exhausts the Nudge tolerance, the agent no longer spews raw logs (`{"level":"error"}`). Instead, it gracefully intercepts the failure and returns a polite fallback response to the user.
+
+## [26.7.18]
+### NPM Global Installation Fixes
+- **Drastic Installation Size Reduction**: Moved UI and Desktop build tools (`electron-builder`, `vite`, `tailwindcss`, `react`, etc.) from `dependencies` to `devDependencies` in the root `package.json`. This ensures global installations (`npm install -g nyxora`) are lightweight and fast.
+- **Removed Deprecation Warnings**: By moving `electron-builder` to `devDependencies`, end-users will no longer see deprecation warnings from legacy upstream dependencies (`inflight`, `rimraf@2`, `glob@7`) during global installation.
+- **Documentation Update**: Removed the `nyxora desktop` command from public CLI documentation, as this command is designed exclusively for local development and standalone distribution, not for global NPM installations.
+
+### Core Agent Enhancements
+- **Robust Context Compression**: Overhauled the context summarizer to eliminate silent API errors (HTTP 400) during long sessions. Introduced `Boundary Snapping` to guarantee that LLM tool calls and tool responses are never split during truncation. Implemented `Soft Archiving` in the SQLite `messages` table, allowing the UI to transparently render the entire conversation history while keeping the LLM context efficiently compressed.
+
+## [26.7.17]
+### NPM Global Publishing & Monorepo Enhancements
+- **Global `npm install` Support**: Merged `packages/desktop` dependencies (`react`, `electron`, `vite`, etc.) into the root `package.json`. This ensures that when users run `npm install -g nyxora`, all dependencies required for the Desktop MVP are installed gracefully without causing read-only permission errors in the global directory.
+- **ML Engine Auto-Setup (`postinstall`)**: Engineered `scripts/install-ml-engine.js` and hooked it into NPM's `postinstall` lifecycle. The framework now automatically spins up an isolated Python virtual environment at `~/.nyxora/ml-engine/venv` and installs all AI dependencies in the background during global installation.
+- **CLI Desktop Hardening**: Stripped out the dynamic `npm install` mechanism from the `nyxora desktop` command, relying entirely on the new robust global dependency resolution to prevent `EACCES` permission errors for end-users.
+
+## [26.7.16]
+### Architecture Upgrade
+- **Docker Sandbox Execution (`run_terminal_command`)**: Upgraded terminal execution tool to support an isolated environment (`envType: "docker"`). When enabled, commands run inside an ephemeral Docker container (default: `python:3.11-slim`), safely sandboxing code execution and file manipulation from the host OS.
+- **Trajectory Generation (`TrajectoryLogger`)**: Implemented automated dataset generation. The agent loop now hooks into `TrajectoryLogger` to save execution histories as JSONL files (`~/.nyxora/trajectories.jsonl`). Trajectories are formatted with `<tool_call>` and `<tool_response>` tags, ready for next-gen tool-calling model fine-tuning.
+- **Subagent Delegation (`delegate_subagent`)**: Empowered the core agent with the ability to recursively spawn isolated clone instances. Using the new `delegate_subagent` skill, the agent can dispatch long-running or complex tasks in parallel without polluting the main context window.
+- **Terminal User Interface (TUI)**: Developed a native TUI using `blessed` for non-GUI / VPS users. Features a multi-pane layout (Chat, Active Tools, Subagents) and utilizes SSE streaming to render real-time LLM responses identically to the Web Dashboard. Launch via `nyxora tui`.
+
+### Features & Platform Expansion
+- **Nyxora Desktop MVP**: Successfully engineered and launched a native, standalone Desktop Application using Electron, Vite, and React.
+  - The desktop client seamlessly mirrors the sleek aesthetic of the web dashboard while providing a native OS-level experience.
+  - Introduced the new `nyxora desktop` CLI command. Running this command autonomously fetches dependencies, builds the renderer, and launches the Electron wrapper.
+  - **Zero-Touch Daemon Sync**: Implemented an intelligent lifecycle manager within the Electron main process. The app autonomously bootstraps the Nyxora background daemon (`nyxora start`) upon launch and securely tears it down when closed.
+  - **Race Condition & Auth Security Fix**: Engineered a robust asynchronous waiting mechanism and internal Vite proxy (`vite.config.ts`) to flawlessly synchronize the `runtime.token` injection between the backend daemon and the frontend UI, completely eradicating startup race conditions and CORS origin blocks.
+
+### Self-Learning & Continuous Improvement
+- **Proactive Tool-Iteration Trigger**: Refactored the core agent loop (`osAgent.ts`) to proactively trigger the background review engine (`ml-engine`) after every 10 tool iterations, rather than waiting for an arbitrary session end or a 3-minute idle timeout.
+- **Aggressive Skill Creation**: Upgraded the `_COMBINED_REVIEW_PROMPT` in `ml-engine` to explicitly command the AI to be highly active in creating and patching skills. Frustration and user corrections are now treated as "FIRST-CLASS skill signals".
+- **Deep Context Window**: Expanded the history payload sent to the background review engine from 30 messages to 100 messages, ensuring the background reviewer has the complete context of long debugging struggles.
+- **UI Learning Notifications**: The core gateway now awaits the background review's execution result. When the AI successfully creates or patches a skill, a `💾 Self-improvement review` system message is automatically injected into the chat UI, providing immediate transparency that the agent is learning.
+- **Persistent System Corrections**: Upgraded the Reflection Engine's schema (`reflection.ts`) to extract and permanently store `system_correction` memories. The AI now actively remembers explicit user rules regarding tool limitations or preferred workflows across all future sessions.
+- **UI Tool Status Sanitization**: Fixed a visual bug where raw JSON tool arguments and execution states were leaking into the chat interface. Upgraded `getToolLabel` (`osAgent.ts`) to aggressively truncate tool outputs and provide clean status indicators.
+
+## [26.7.15]
+### Bug Fixes
+
+#### Sudo Command Refused by LLM
+- **Root Cause**: The `[SUDO & PACKAGE INSTALL STRATEGY]` section in `promptBuilder.ts` was written before `run_terminal_command_pty` existed. It told the LLM "this tool runs in a NON-INTERACTIVE shell" and instructed it to tell the user to run sudo manually — causing the LLM to refuse all sudo commands.
+- **Fix (`promptBuilder.ts`)**: Rewrote the SUDO section. LLM now knows it has two terminal tools (`run_terminal_command` for non-interactive, `run_terminal_command_pty` for sudo/interactive), is instructed to ALWAYS use PTY for sudo, and is explicitly told it is "FULLY CAPABLE of running sudo commands." Password injection from `config.yaml → security.sudo_password` is handled automatically by the PTY tool.
+
+#### LLM Output Repetition Loop
+- **Root Cause**: When the LLM was corrected by the user (e.g., after giving wrong sports results), it entered an uncertain state and looped — echoing the same phrase in multiple rephrasings within a single response (e.g., "gue kabarin hasilnya kalo mau, gue kabarin hasilnya begitu selesai, gue kabarin aja kabarin aja...").
+- **Fix #1 (`llmProvider.ts`)**: Added `frequency_penalty: 0.6` and `presence_penalty: 0.3` to all `OpenAIAdapter.chat()` and `.stream()` calls. These parameters suppress token-level repetition at the API level, effective for all OpenAI-compatible providers (Groq, OpenRouter, xAI, Mistral, DeepSeek, etc.).
+- **Fix #2 (`promptBuilder.ts`)**: Added `[ANTI-REPETITION]` rule to the universal discipline prompt: LLM is instructed to never repeat the same phrase, clause, or sentence more than once per response — if it catches itself echoing, it must STOP immediately.
+
+#### Search Inaccuracy / Hallucination on Factual Queries
+- **Root Cause (5 bugs identified)**:
+  1. Temporal keyword `"tadi"` (and others: `kemarin`, `besok`, `pagi ini`, etc.) not detected → date not injected → search engine returned mixed results from multiple years.
+  2. LLM frequently ignored `depth=2` instruction in tool description → only snippets fetched → scores/data in article body never reached LLM context.
+  3. No `isFactualQuery` detection → sport/news/journal queries not auto-upgraded to `depth=2`.
+  4. No rule forbidding LLM from filling data gaps using training memory after an ambiguous search result.
+  5. No source citation enforcement → LLM gave hallucinated facts without accountability.
+- **Fix #1 (`searchWeb.ts`)**: Expanded `isTimeSensitive` detection with 15+ new Indonesian/English temporal keywords (`tadi`, `kemarin`, `besok`, `malam ini`, `pagi ini`, `sore ini`, `minggu ini`, `bulan ini`, `baru saja`, `habis`, `sudah selesai`, `yesterday`, `tomorrow`, `this week`, `recent`, `breaking`). Added proper date arithmetic for `kemarin`/`yesterday` (now−1 day) and `besok`/`tomorrow` (now+1 day).
+- **Fix #2 (`searchWeb.ts`)**: Added `isFactualQuery` detector covering sports (skor, hasil, pertandingan, piala, liga, klasemen), news (berita, kejadian), journals (jurnal, penelitian, paper, studi), and finance (harga, saham, inflasi). Factual queries auto-upgrade to `effectiveDepth = Math.max(depth, 2)` regardless of LLM's depth argument.
+- **Fix #3 (`searchWeb.ts`)**: Added `[SEARCH_CONFIDENCE: HIGH/MEDIUM/LOW]` signal to all search outputs. Confidence is derived from how many top-3 articles were successfully scraped. If `LOW` on a factual/temporal query, an explicit warning is injected into the tool result instructing the LLM to admit data unavailability instead of guessing.
+- **Fix #4 (`promptBuilder.ts`)**: Replaced `<web_search_accuracy>` section with stronger `[GROUNDED ANSWERS ONLY]` rule: after calling `search_web`, answers must be based strictly on search results. If `[SEARCH_CONFIDENCE: LOW]` or the specific fact is absent, LLM must say "Gue belum nemu data yang spesifik dari search" — never fill gaps from training memory for 2024–2026 events.
+- **Fix #5 (`promptBuilder.ts`)**: Added `[SOURCE CITATION]` enforcement: when stating any specific fact (score, result, date, statistic), LLM must include the source URL.
+## [26.7.14]
+### Agent Identity & Execution Discipline Overhaul
+- **Semantic Intent Router Refactor (`reasoning.ts`)**: Upgraded the intent router to utilize a strict \`CLASSIFICATION MATRIX\` and Context Hierarchy Rules. This completely eradicates intent misclassification between Web3 and OS workflows, especially during context-switching.
+- **Agent Identity Compression (`promptBuilder.ts`)**: Consolidated verbose \`[CRITICAL EXECUTION RULES]\` into 5 high-impact, token-efficient mandates (e.g., OUTPUT RESTRICTION, THINKING GATE, HARD HARDENING) to maximize model attention retention.
+- **Strict Real-World Facts Guardrail**: Introduced mandatory \`search_web\` requirements for sports scores, schedules, and real-world news to completely eliminate LLM hallucination on dynamic data.
+- **Anti-Silent Stop / Interactive Execution Flow (`promptBuilder.ts`)**: Replaced standard tool-call enforcements with \`[INTERACTIVE EXECUTION FLOW]\`. The agent is now permitted exactly one short conversational sentence before a tool call (both on success and recovery paths), but is strictly forbidden from ending its turn without attaching the corrected tool payload. This cures the "Silent Stop" / "Promise Without Action" bug while maintaining a natural, conversational UX.
+- **Force Action User Correction (`osAgent.ts`)**: Refactored the User Correction Detectors to intercept scoldings with a \`[CRITICAL INTERCEPT: USER CORRECTION]\` signal. The LLM is now forced to fetch fresh ground-truth data via tools instead of endlessly apologizing and recycling stale context.
+
+### UI/UX & Quality of Life
+- **Import Project Workflow Redesign**: Relocated the "Import Project" button from the main navigation sidebar into the "Workspaces" section header. The action is now represented by an intuitive `+` icon that perfectly scales with the slightly enlarged `0.85rem` section text, achieving a significantly cleaner UI layout while keeping workspace management centralized.
+
+### Performance — LLM Response Speed Optimization
+
+#### Cold Start Latency Fix
+- **Non-Blocking DeFi Aggregator Discovery** (`server.ts`): `aggregatorRegistry.autoDiscover()` was previously `await`-ed synchronously before `app.listen()`, blocking the entire server startup by 2–5 seconds while it probed external DeFi providers. Refactored to `setImmediate()` fire-and-forget so the server starts accepting LLM requests immediately after plugins are loaded, with provider discovery happening in the background.
+- **ML Engine Fetch Timeout** (`promptBuilder.ts`): All 3 network calls to the local Python ML Engine (`/memory/rag`, `/memory/narrative`, `/skills/list`) previously had no timeout. During cold start, when the ML Engine is still booting, these calls would hang for up to 2 minutes waiting for a TCP connection. Added `AbortSignal.timeout(1500)` to each fetch — if the ML Engine is not ready, calls fail in ≤1.5s and return empty strings gracefully, keeping the first LLM response fast.
+
+#### Per-Request Latency Optimization
+- **Parallel Volatile Prompt Parts** (`promptBuilder.ts`): `buildEpisodicMemories()` and `buildNarrativeMemories()` were called sequentially (`await` one, then `await` the other). Refactored to `Promise.all([...])` — both network calls now run concurrently, saving ~300–600ms per request.
+- **Parallel Narrative + Skills Fetch** (`promptBuilder.ts`): Inside `buildNarrativeMemories()`, the `/memory/narrative` and `/skills/list` fetches were also sequential. Parallelized with `Promise.all()`.
+- **TTL Cache for Narrative Memory & Skills** (`promptBuilder.ts`): Added a 30-second in-memory TTL cache for narrative memory and skills list. These change only when the user explicitly saves something — re-fetching on every message was wasteful. Cache hit returns instantly with zero network overhead.
+- **5-Second Build Cache** (`promptBuilder.ts`): Added a short-lived cache keyed by `agentType + userInput[:80]`. Prevents double-building the system prompt when the router warm-up and the agent's own `getSystemPrompt()` call happen within 5 seconds of each other.
+- **Parallel LLM Router + System Prompt Warm-Up** (`reasoning.ts`): For messages that don't match any keyword (triggering the LLM semantic router), the router call and the OS system prompt pre-build now run **simultaneously** via `Promise.all()`. Since `'os'` is the most common fallback, its system prompt is pre-warmed into the 5s build cache while the router is deciding — making the router's latency effectively invisible to the user. Applies to both sync and stream paths.
+- **Static Import for `historySanitizer`** (`osAgent.ts`, `web3Agent.ts`): Dynamic `require('../utils/historySanitizer')` inside function bodies (4 occurrences across 2 files) replaced with static ES `import` at the top of each file.
+
+## [26.7.12]
+### Features
+- **TTY Support for Interactive Commands**: Introduced a new tool `run_terminal_command_pty` implemented using `node-pty` to handle interactive shell commands (like `vim`, `nano`, and REPLs). Nyxora can now automatically execute `sudo` commands by securely injecting a password from `~/.nyxora/config/config.yaml`.
+- **Tool Selection Safeguards**: Implemented a defense system (Clearer Descriptions and Runtime Auto-Detection) to help the LLM choose the correct terminal tool and gracefully fail if `sudo` is used with the non-PTY tool.
+
+### Performance
+- **Context Compression Optimization**: Refactored the agent loop to move context summarization (`compressHistory`) to a one-time operation before the loop starts, reducing redundant LLM calls by up to 66% and improving response time by ~33%.
+
+## [26.7.11]
+### Bug Fixes & Stability
+- **Ghost Daemon & Stale Transactions Fix**: Resolved a critical issue where the `Nyx Daemon` leaked into the interactive CLI chat due to a static top-level import in `cli.ts`. Replaced with a dynamic import to keep the CLI environment pure. Additionally, overhauled the SQLite transaction manager by introducing a 3-minute transaction timeout (previously there was no expiration), and implemented an `auto-cleanup` mechanism that forcefully purges (`failed`) all stale pending transactions upon daemon startup to prevent persistent "ghost" transaction prompts after forced system shutdowns.
 
 ## [26.7.10]
 ### Web3 Integrations

package/README.md

@@ -97,7 +97,9 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 
 ### 💻 OS & Web2 Skills (Off-Chain)
 *   **Google Workspace Automation 🚀**: Transform Nyxora into your ultimate personal assistant. The agent can read your latest Gmail inbox, check your Google Calendar, extract text from Google Docs, and even append expense/trading logs directly to your Google Sheets.
-*   **System Automation & Full OS Access**: Instruct the agent to read/write local files, run terminal commands, and browse the web natively.
+*   **System Automation & Full OS Access**: Instruct the agent to read/write local files, run interactive terminal commands (with secure `sudo` password auto-injection), and browse the web natively.
+*   **Docker Sandbox Execution**: Safely run untrusted code and manipulate files inside an isolated, ephemeral Docker container environment to protect your host OS.
+*   **Recursive Subagent Delegation**: Dispatch long-running or highly complex tasks to isolated clone subagents that run in parallel without clogging your main conversational context window.
 *   **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!
@@ -137,7 +139,7 @@ graph TD
     User["User / External Client"]:::external
 
     Dashboard["Dashboard (UI)<br/>Port 5173"]:::ui
-    MCP["MCP Server<br/>Port 3001"]:::ui
+    MCP["MCP Server<br/>(Stdio / JSON-RPC)"]:::ui
 
     Core["Core LLM Runtime<br/>Port 3000<br/>(NLP Parsing, Routing, Agent Logic)"]:::core
 
@@ -186,7 +188,7 @@ To dive deeper into the technical details of our Zero-Knowledge security archite
 ## 🚀 Quick Start & Installation
 
 ### Prerequisites
-Nyxora requires **Node.js 18+** and **Python 3.10+** (for the ML Cognitive Engine) to be installed on your system.
+Nyxora requires **Node.js 22+** and **Python 3.10+** (for the ML Cognitive Engine) to be installed on your system.
 
 ### Option 1: One-Line Installation (Recommended)
 The fastest way to install Nyxora is via our smart installation wrapper. This script automatically prepares Node.js (if missing) and securely fetches the Nyxora daemon directly from the NPM Registry. *(Note: You must have Python 3.10+ pre-installed on your system, as this script only handles Node.js dependencies).*
@@ -208,6 +210,8 @@ If you already have Node.js installed, you can natively install Nyxora globally
 # Install globally
 npm install -g nyxora
 
+> 💡 **ML Engine Setup**: When you run `npm install -g nyxora`, the Python ML Engine dependencies are automatically installed via the `postinstall` script. Requires Python 3.10+.
+
 # Run the interactive setup wizard 
 # (Automatically validates Node.js & Python 3.10+ requirements, configures API Keys, Wallet, and ML Environment)
 nyxora setup
@@ -217,6 +221,12 @@ nyxora start
 
 # Open the interactive UI dashboard
 nyxora dashboard
+
+# 🖥️ Open the interactive Terminal UI (for VPS/CLI users)
+nyxora tui
+
+# 💬 Chat interactively via the terminal
+nyxora chat
 ```
 
 ### Option 2: Local Development (Source Code)
@@ -229,7 +239,7 @@ cd Nyxora
 # 1. Install Dependencies
 npm install
 
-# 2. Build the Core, MCP Server, and Dashboard UI
+# 2. Build the Core, TUI, MCP Server, and Dashboard UI
 npm run build
 
 # 3. Interactive Setup Wizard (Will also install Python ML requirements via pip)
@@ -237,6 +247,9 @@ npm run setup
 
 # 4. Start the Application (Spawns Node.js Core and Python FastAPI sidecar)
 npm start
+
+# 5. (Optional) Run the Desktop App locally
+npm run desktop
 ```
 
 *(If you are actively developing and modifying the source code, use `npm run dev` to enable hot-reloading for the frontend and backend).*

package/bin/nyxora.mjs

@@ -73,6 +73,7 @@ async function start() {
   const child = spawn(cmd, args, {
     cwd: projectRoot,
     detached: true,
+    windowsHide: true,
     stdio: ['ignore', out, err],
     env: { ...process.env, TS_NODE_CACHE: 'false' }
   });
@@ -91,7 +92,12 @@ async function stop(preserveTracker = false) {
   if (pid) {
     console.log(`Stopping Nyxora daemon (PID: ${pid})...`);
     try {
-      process.kill(-pid, 'SIGTERM');
+      if (process.platform === 'win32') {
+        const { spawnSync } = await import('child_process');
+        spawnSync('taskkill', ['/pid', pid.toString(), '/t', '/f']);
+      } else {
+        process.kill(-pid, 'SIGTERM');
+      }
       let attempts = 0;
       while (isDaemonRunning(pid.toString()) && attempts < 20) {
         await new Promise(r => setTimeout(r, 100));
@@ -362,6 +368,8 @@ async function serveMcp() {
   await new Promise(resolve => child.on('close', resolve));
 }
 
+
+
 async function main() {
   switch(command) {
     case 'doctor': await runDoctor(); break;
@@ -379,6 +387,41 @@ async function main() {
     case 'clean-logs': await cleanLogs(); break;
     case 'autostart': await autostart(process.argv[3]); break;
     case 'mcp': await serveMcp(); break;
+
+    case 'desktop': {
+      const desktopPkg = path.join(projectRoot, 'packages/desktop/package.json');
+      const desktopDist = path.join(projectRoot, 'packages/desktop/dist-electron');
+      if (!fs.existsSync(desktopPkg) || !fs.existsSync(desktopDist)) {
+        console.error('❌ Desktop app is not available in the npm package.');
+        console.error('   The Desktop app must be built from source.');
+        console.error('   Clone the repo and run: git clone https://github.com/nyxoraAI/Nyxora && cd Nyxora && npm install && npm run desktop');
+        process.exit(1);
+      }
+      const { default: open } = await import('open');
+      await open(desktopDist);
+      break;
+    }
+
+    case 'tui': {
+      // Spawn pre-compiled TUI directly using Node.
+      // We must avoid wrappers like `npx` or `npm run` which spawn subshells 
+      // and break TTY inheritance, causing Ink to think it's not a TTY (which makes it invisible).
+      const tuiDist = path.join(projectRoot, 'packages/tui/dist/index.js');
+      if (!fs.existsSync(tuiDist)) {
+        console.error('❌ TUI is not available (missing compiled output).');
+        console.error('   If you installed from npm, try: npm install -g nyxora@latest');
+        console.error('   If running from source: npm run build');
+        process.exit(1);
+      }
+      
+      const childTui = spawn('node', [tuiDist], {
+        cwd: path.join(projectRoot, 'packages/tui'),
+        stdio: 'inherit',
+        env: { ...process.env }
+      });
+      await new Promise(resolve => childTui.on('close', resolve));
+      break;
+    }
     case '-v':
     case '--v':
     case '--version':

package/dist/launcher.js

@@ -35,7 +35,7 @@ const spawnService = (name, command, args, env, inheritStdio = false, cwd) => {
     let crashWindowStart = Date.now();
     let isShuttingDown = false;
     const startProcess = () => {
-        const spawnOpts = { env, stdio: inheritStdio ? 'inherit' : 'pipe' };
+        const spawnOpts = { env, stdio: inheritStdio ? 'inherit' : 'pipe', windowsHide: true };
         if (cwd)
             spawnOpts.cwd = cwd;
         child = (0, child_process_1.spawn)(command, args, spawnOpts);
@@ -66,6 +66,11 @@ const spawnService = (name, command, args, env, inheritStdio = false, cwd) => {
             }
             crashCount++;
             if (crashCount > 5) {
+                if (name === 'ML Engine') {
+                    console.error(`[Launcher] ML Engine crashed 5 times. Disabling it to prevent system shutdown.`);
+                    isShuttingDown = true;
+                    return;
+                }
                 console.error(`[Launcher] FATAL: ${name} crashed 5 times in 1 minute. Initiating emergency shutdown.`);
                 isShuttingDown = true;
                 try {
@@ -147,7 +152,8 @@ setTimeout(() => {
         const IS_WINDOWS_LAUNCHER = process.platform === 'win32';
         const pythonBinDir = IS_WINDOWS_LAUNCHER ? 'Scripts' : 'bin';
         const pythonExe = IS_WINDOWS_LAUNCHER ? 'python.exe' : 'python';
-        const pythonPath = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'ml-engine', 'venv', pythonBinDir, pythonExe);
+        const defaultPythonPath = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'ml-engine', 'venv', pythonBinDir, pythonExe);
+        const pythonPath = process.env.ML_ENGINE_PYTHON_PATH || defaultPythonPath;
         if (fs_1.default.existsSync(pythonPath)) {
             let mlDir = path_1.default.join(__dirnameResolved, 'packages', 'ml-engine');
             if (!fs_1.default.existsSync(mlDir))
@@ -184,7 +190,7 @@ setTimeout(() => {
                 catch (e) { }
                 if (cfEnabled) {
                     console.log('[Launcher] Starting Auto-Tunnel (Cloudflare) on port 3000...');
-                    const cf = (0, child_process_1.spawn)('npx', ['cloudflared', 'tunnel', '--url', 'http://localhost:3000'], { env, shell: true });
+                    const cf = (0, child_process_1.spawn)('npx', ['cloudflared', 'tunnel', '--url', 'http://localhost:3000'], { env, shell: true, windowsHide: true });
                     children.push({
                         kill: () => { try {
                             process.kill(cf.pid, 'SIGTERM');

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

@@ -42,11 +42,55 @@ const parser_1 = require("../config/parser");
 const telegram_1 = require("../channels/telegram");
 const crypto_1 = require("crypto");
 const picocolors_1 = __importDefault(require("picocolors"));
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("../config/paths");
+const CRON_PERSIST_FILE = (0, paths_1.getPath)('cron_jobs.json');
+function loadPersistedJobs() {
+    try {
+        if (fs_1.default.existsSync(CRON_PERSIST_FILE)) {
+            const raw = fs_1.default.readFileSync(CRON_PERSIST_FILE, 'utf-8');
+            return JSON.parse(raw);
+        }
+    }
+    catch (e) {
+        console.warn(picocolors_1.default.yellow('[Cron] Failed to load persisted jobs, starting fresh.'));
+    }
+    return [];
+}
+function savePersistedJobs(jobs) {
+    try {
+        const data = Array.from(jobs.values()).map(j => ({
+            id: j.id,
+            expression: j.expression,
+            prompt: j.prompt,
+            createdAt: j.createdAt
+        }));
+        fs_1.default.writeFileSync(CRON_PERSIST_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red('[Cron] Failed to persist jobs:'), e);
+    }
+}
 class CronManager {
     jobs = new Map();
-    addJob(expression, prompt, sessionId) {
-        const id = (0, crypto_1.randomUUID)();
-        // Validate expression
+    constructor() {
+        // Restore jobs from disk on startup
+        const persisted = loadPersistedJobs();
+        if (persisted.length > 0) {
+            console.log(picocolors_1.default.cyan(`[Cron] Restoring ${persisted.length} persisted job(s) from disk...`));
+            for (const saved of persisted) {
+                try {
+                    this._scheduleJob(saved.id, saved.expression, saved.prompt, saved.createdAt);
+                    console.log(picocolors_1.default.green(`[Cron] ✓ Restored job ${saved.id} (${saved.expression})`));
+                }
+                catch (e) {
+                    console.warn(picocolors_1.default.yellow(`[Cron] ✗ Skipped invalid job ${saved.id}: ${e.message}`));
+                }
+            }
+        }
+    }
+    _scheduleJob(id, expression, prompt, createdAt) {
+        // Validate expression first
         try {
             new croner_1.Cron(expression);
         }
@@ -56,11 +100,8 @@ class CronManager {
         const task = new croner_1.Cron(expression, async () => {
             console.log(picocolors_1.default.cyan(`[Cron] Executing job ${id}: "${prompt}"`));
             try {
-                // Dynamically import processUserInput to avoid circular dependencies
                 const { processUserInput } = await Promise.resolve().then(() => __importStar(require('./reasoning')));
-                // Execute the prompt as a background system task
-                const response = await processUserInput(prompt, 'system', undefined, sessionId || `cron-${id}`);
-                // Push notification to Telegram if configured
+                const response = await processUserInput(prompt, 'system', undefined, `cron-${id}`);
                 const config = (0, parser_1.loadConfig)();
                 if (config.integrations?.telegram?.enabled && config.integrations?.telegram?.authorized_chat_id) {
                     const message = `🤖 *AI Scheduled Report*\n\n${response}`;
@@ -75,13 +116,12 @@ class CronManager {
                 }
             }
         });
-        this.jobs.set(id, {
-            id,
-            expression,
-            prompt,
-            task,
-            createdAt: Date.now()
-        });
+        this.jobs.set(id, { id, expression, prompt, task, createdAt });
+    }
+    addJob(expression, prompt, sessionId) {
+        const id = (0, crypto_1.randomUUID)();
+        this._scheduleJob(id, expression, prompt, Date.now());
+        savePersistedJobs(this.jobs);
         console.log(picocolors_1.default.green(`[Cron] Scheduled new job ${id} with expression '${expression}'`));
         return id;
     }
@@ -90,6 +130,7 @@ class CronManager {
         if (job) {
             job.task.stop();
             this.jobs.delete(id);
+            savePersistedJobs(this.jobs);
             console.log(picocolors_1.default.yellow(`[Cron] Removed job ${id}`));
             return true;
         }