nyxora 26.7.2 → 26.7.3

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

@@ -24,15 +24,22 @@ function formatToTelegramHTML(text) {
         .replace(/&/g, '&')
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;');
-    html = html.replace(/\*\*(.*?)\*\*/g, '<b>$1</b>');
-    html = html.replace(/(?<!^|\n)\*(?!\s)(.*?)(?<!\s)\*/g, '<i>$1</i>');
-    html = html.replace(/_(.*?)_/g, '<i>$1</i>');
-    html = html.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>');
-    html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
     html = html.replace(/&lt;thought&gt;[\s\S]*?&lt;\/thought&gt;\n?/g, '');
     html = html.replace(/<thought>[\s\S]*?<\/thought>\n?/g, '');
     html = html.replace(/&lt;think&gt;[\s\S]*?&lt;\/think&gt;\n?/g, '');
     html = html.replace(/<think>[\s\S]*?<\/think>\n?/g, '');
+    html = html.replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>');
+    html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
+    html = html.replace(/\*\*(.*?)\*\*/g, (match, p1) => {
+        if (p1.includes('<pre>') || p1.includes('<code>'))
+            return match;
+        return `<b>${p1}</b>`;
+    });
+    html = html.replace(/(?<!^|\n)\*(?!\s)(.*?)(?<!\s)\*/g, (match, p1) => {
+        if (p1.includes('<b>') || p1.includes('</b>') || p1.includes('<pre>') || p1.includes('<code>'))
+            return match;
+        return `<i>${p1}</i>`;
+    });
     const tableRegex = /(?:\|.*\|(?:\n|$))+/g;
     html = html.replace(tableRegex, (match) => {
         return `<pre>${match.trim()}</pre>\n`;
@@ -51,6 +58,20 @@ function startTelegramBot() {
         globalBotInstance = bot;
         const throttler = (0, transformer_throttler_1.apiThrottler)();
         bot.api.config.use(throttler);
+        bot.api.config.use(async (prev, method, payload, signal) => {
+            try {
+                return await prev(method, payload, signal);
+            }
+            catch (err) {
+                if (method === 'getUpdates' && err.message?.includes('ETIMEDOUT')) {
+                    console.log(picocolors_1.default.yellow('[Telegram] API connection lost (Timeout). Retrying automatically...'));
+                }
+                else if (method === 'getUpdates') {
+                    console.log(picocolors_1.default.yellow(`[Telegram] Failed to fetch updates: ${err.message}`));
+                }
+                throw err; // Rethrow so the runner can gracefully backoff and retry
+            }
+        });
         const isPaired = !!config.integrations?.telegram?.authorized_chat_id;
         let generatedPin = '';
         let pinExpiry = 0;
@@ -103,7 +124,7 @@ function startTelegramBot() {
             return;
         });
         bot.command('clear', async (ctx) => {
-            reasoning_1.logger.clear(ctx.chat?.id.toString());
+            reasoning_1.logger.clear(`telegram_${ctx.chat?.id}`);
             await ctx.reply("✅ AI memory has been cleared. Let's start a new chat!");
         });
         bot.on('message:text', async (ctx) => {
@@ -112,30 +133,103 @@ function startTelegramBot() {
                 return;
             console.log(`[Telegram] Received from ${ctx.from?.first_name || 'User'}: ${text}`);
             await ctx.replyWithChatAction('typing');
-            try {
-                let progressMsgId = null;
-                const onProgress = async (progressText) => {
+            // No need for a placeholder message anymore! We use ephemeral drafts.
+            const draft_id = Math.floor(Math.random() * 100000000) + 1;
+            let buffer = '';
+            let lastDraftAt = 0;
+            let isDrafting = false;
+            const THROTTLE_MS = 100; // Native drafts can be streamed incredibly fast
+            const onChunk = async (chunk) => {
+                buffer += chunk;
+                const now = Date.now();
+                if (!isDrafting && now - lastDraftAt >= THROTTLE_MS) {
+                    isDrafting = true;
                     try {
-                        if (!progressMsgId) {
-                            const sent = await ctx.reply(`<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
-                            progressMsgId = sent.message_id;
-                        }
-                        else {
-                            await ctx.api.editMessageText(ctx.chat.id, progressMsgId, `<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
-                        }
+                        await ctx.api.sendMessageDraft(ctx.chat.id, draft_id, formatToTelegramHTML(buffer), { parse_mode: 'HTML' });
                     }
                     catch { }
-                };
-                const response = await (0, reasoning_1.processUserInput)(text, 'user', onProgress, `telegram_${ctx.chat?.id}`);
-                if (progressMsgId) {
-                    await ctx.api.deleteMessage(ctx.chat.id, progressMsgId).catch(() => { });
+                    lastDraftAt = Date.now();
+                    isDrafting = false;
                 }
-                // Transactions will now use conversational approval (Zero-Latency text prompts) instead of InlineKeyboards.
-                await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML' });
+            };
+            const onProgress = async (msg) => {
+                if (!isDrafting) {
+                    isDrafting = true;
+                    try {
+                        await ctx.api.sendMessageDraft(ctx.chat.id, draft_id, `<i>${msg.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
+                    }
+                    catch { }
+                    isDrafting = false;
+                }
+            };
+            try {
+                const response = await (0, reasoning_1.processUserInputStream)(text, onChunk, onProgress, `telegram_${ctx.chat?.id}`);
+                // Finalize by sending the permanent message (which replaces the draft)
+                let replyMarkup = undefined;
+                if (/Reply \*\*Yes\*\*/i.test(response) && /\*\*No\*\* to cancel/i.test(response)) {
+                    replyMarkup = new grammy_1.InlineKeyboard()
+                        .text('✅ Approve', 'tx_approve')
+                        .text('❌ Reject', 'tx_reject');
+                }
+                await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML', reply_markup: replyMarkup }).catch((e) => {
+                    console.error("[Telegram] CRITICAL: ctx.reply failed in text handler:", e.message);
+                });
             }
             catch (error) {
                 console.error('[Telegram] Error processing message:', error);
-                await ctx.reply('❌ Sorry, I encountered an error while processing your message.');
+                await ctx.reply('❌ Sorry, I encountered an error while processing your message.', {}).catch(() => { });
+            }
+        });
+        bot.on('callback_query:data', async (ctx) => {
+            const data = ctx.callbackQuery.data;
+            if (data === 'tx_approve' || data === 'tx_reject') {
+                await ctx.answerCallbackQuery().catch(() => { });
+                await ctx.editMessageReplyMarkup(undefined).catch(() => { });
+                const simulatedText = data === 'tx_approve' ? 'yes' : 'no';
+                console.log(`[Telegram] User clicked ${simulatedText.toUpperCase()} via Inline Keyboard`);
+                if (!ctx.chat)
+                    return;
+                await ctx.replyWithChatAction('typing');
+                const draft_id = Math.floor(Math.random() * 100000000) + 1;
+                let buffer = '';
+                let lastDraftAt = 0;
+                let isDrafting = false;
+                const onChunk = async (chunk) => {
+                    buffer += chunk;
+                    const now = Date.now();
+                    if (!isDrafting && now - lastDraftAt >= 100) {
+                        isDrafting = true;
+                        try {
+                            await ctx.api.sendMessageDraft(ctx.chat.id, draft_id, formatToTelegramHTML(buffer), { parse_mode: 'HTML' });
+                        }
+                        catch { }
+                        lastDraftAt = Date.now();
+                        isDrafting = false;
+                    }
+                };
+                const onProgress = async (msg) => {
+                    if (!isDrafting) {
+                        isDrafting = true;
+                        try {
+                            await ctx.api.sendMessageDraft(ctx.chat.id, draft_id, `<i>${msg.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
+                        }
+                        catch { }
+                        isDrafting = false;
+                    }
+                };
+                try {
+                    const response = await (0, reasoning_1.processUserInputStream)(simulatedText, onChunk, onProgress, `telegram_${ctx.chat.id}`);
+                    let replyMarkup = undefined;
+                    if (/Reply \*\*Yes\*\*/i.test(response) && /\*\*No\*\* to cancel/i.test(response)) {
+                        replyMarkup = new grammy_1.InlineKeyboard().text('✅ Approve', 'tx_approve').text('❌ Reject', 'tx_reject');
+                    }
+                    await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML', reply_markup: replyMarkup }).catch((e) => {
+                        console.error("[Telegram] CRITICAL: ctx.reply failed in callback:", e.message);
+                    });
+                }
+                catch (error) {
+                    await ctx.reply('❌ Sorry, I encountered an error.', {}).catch(() => { });
+                }
             }
         });
         bot.on('message:document', async (ctx) => {
@@ -183,7 +277,9 @@ function startTelegramBot() {
         bot.catch((err) => {
             console.error('[Telegram] Grammy error:', err);
         });
-        runnerInstance = (0, runner_1.run)(bot);
+        runnerInstance = (0, runner_1.run)(bot, {
+            runner: { silent: true }
+        });
         if (isPaired) {
             console.log('🤖 Telegram Bot is running and securely listening for your messages...');
         }

package/dist/packages/core/src/memory/episodic.js

@@ -36,11 +36,17 @@ class EpisodicMemoryDB {
       CREATE TABLE IF NOT EXISTS user_personas (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         trait TEXT UNIQUE NOT NULL,
+        category TEXT DEFAULT 'general',
         confidence REAL DEFAULT 0.1,
         source TEXT,
         lastUpdated DATETIME DEFAULT CURRENT_TIMESTAMP
       );
     `);
+        // Migration: add category column if missing (for older DBs)
+        try {
+            this.db.prepare('ALTER TABLE user_personas ADD COLUMN category TEXT DEFAULT \'general\'').run();
+        }
+        catch { }
     }
     addCandidateFact(fact, confidenceScore = 0.5, category = 'general', ruleType = 'observation', keyTopic) {
         if (keyTopic) {
@@ -93,6 +99,10 @@ class EpisodicMemoryDB {
         const stmt = this.db.prepare('DELETE FROM episodic_memories');
         stmt.run();
     }
+    clearAllPersonas() {
+        const stmt = this.db.prepare('DELETE FROM user_personas');
+        stmt.run();
+    }
     close() {
         try {
             this.db.close();
@@ -100,7 +110,11 @@ class EpisodicMemoryDB {
         catch { }
     }
     // --- PERSONA MODELING ---
-    updatePersonaTrait(trait, confidence = 0.5, source = 'honcho') {
+    /**
+     * Legacy method: upsert by exact trait string.
+     * Kept for backward compatibility but prefer upsertPersonaByCategory.
+     */
+    updatePersonaTrait(trait, confidence = 0.5, source = 'nyx_daemon') {
         const existing = this.db.prepare('SELECT id, confidence FROM user_personas WHERE trait = ?').get(trait);
         if (existing) {
             const newConfidence = Math.min(1.0, existing.confidence + (confidence * 0.2));
@@ -108,14 +122,44 @@ class EpisodicMemoryDB {
             stmt.run(newConfidence, source, existing.id);
         }
         else {
-            const stmt = this.db.prepare('INSERT INTO user_personas (trait, confidence, source) VALUES (?, ?, ?)');
-            stmt.run(trait, confidence, source);
+            const stmt = this.db.prepare('INSERT INTO user_personas (trait, category, confidence, source) VALUES (?, ?, ?, ?)');
+            stmt.run(trait, 'general', confidence, source);
+        }
+    }
+    /**
+     * Category-based upsert: each category (language, tone, trading_style, behavior)
+     * has exactly ONE row in user_personas, identified by category.
+     * This ensures confidence accumulates correctly across audit cycles
+     * instead of creating duplicate rows with slightly different phrasing.
+     */
+    upsertPersonaByCategory(category, value, confidence = 0.5, source = 'nyx_daemon') {
+        if (!value || !value.trim())
+            return;
+        const existing = this.db.prepare('SELECT id, confidence FROM user_personas WHERE category = ?').get(category);
+        if (existing) {
+            const newConfidence = Math.min(1.0, existing.confidence + (confidence * 0.2));
+            this.db.prepare('UPDATE user_personas SET trait = ?, confidence = ?, source = ?, lastUpdated = CURRENT_TIMESTAMP WHERE id = ?').run(value.trim(), newConfidence, source, existing.id);
+        }
+        else {
+            this.db.prepare('INSERT INTO user_personas (trait, category, confidence, source) VALUES (?, ?, ?, ?)').run(value.trim(), category, confidence, source);
         }
     }
     getPersonas() {
         const stmt = this.db.prepare('SELECT * FROM user_personas ORDER BY confidence DESC');
         return stmt.all();
     }
+    /**
+     * Get personas filtered by minimum confidence threshold.
+     */
+    getStrongPersonas(minConfidence = 0.5) {
+        const stmt = this.db.prepare('SELECT * FROM user_personas WHERE confidence >= ? ORDER BY confidence DESC');
+        return stmt.all(minConfidence);
+    }
+    deletePersonaByTrait(keyword) {
+        const stmt = this.db.prepare('DELETE FROM user_personas WHERE trait LIKE ?');
+        const result = stmt.run(`%${keyword}%`);
+        return result.changes || 0;
+    }
 }
 exports.EpisodicMemoryDB = EpisodicMemoryDB;
 // Singleton instance

package/dist/packages/core/src/memory/logger.js

@@ -81,6 +81,32 @@ class Logger {
         custom_rules TEXT,
         updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
       )
+    `);
+        // V4: Transaction Persistence
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_transactions (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        chain_name TEXT NOT NULL,
+        details TEXT NOT NULL,
+        status TEXT NOT NULL,
+        result TEXT,
+        nonce TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_withdrawals (
+        id TEXT PRIMARY KEY,
+        l2_tx_hash TEXT NOT NULL,
+        l1_chain TEXT NOT NULL,
+        l2_chain TEXT NOT NULL,
+        portal_address TEXT NOT NULL,
+        user_address TEXT NOT NULL,
+        amount TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
     `);
         // Ensure session_id exists for older DBs
         try {
@@ -158,7 +184,7 @@ class Logger {
       ORDER BY s.timestamp DESC
     `).all(term, term);
     }
-    getHistory(sessionId, limit = 40) {
+    getHistory(sessionId, limit = 70) {
         let rows;
         // Phase 2: Sliding Window Algorithm (LLM Context Limit)
         // Fetch only the last X messages, then order them chronologically
@@ -198,13 +224,45 @@ class Logger {
             return entry;
         });
     }
+    /**
+     * Returns the N most recent messages across ALL sessions (including Telegram, Discord, and NULL sessions).
+     * Used by NyxDaemon to analyze conversation history from every channel.
+     */
+    getRecentMessagesAllSessions(limit = 30) {
+        const rows = this.db.prepare(`
+      SELECT * FROM (
+        SELECT role, content, name, tool_call_id, tool_calls, session_id, id
+        FROM messages
+        ORDER BY id DESC LIMIT ?
+      ) ORDER BY id ASC
+    `).all(limit);
+        return rows.map((row) => {
+            const entry = {
+                role: row.role,
+                content: row.content,
+            };
+            if (row.name)
+                entry.name = row.name;
+            if (row.tool_call_id)
+                entry.tool_call_id = row.tool_call_id;
+            if (row.tool_calls)
+                entry.tool_calls = JSON.parse(row.tool_calls);
+            if (row.session_id)
+                entry.session_id = row.session_id;
+            return entry;
+        });
+    }
     addEntry(entry, sessionId) {
         if (sessionId) {
             // Auto-create session if it doesn't exist (e.g. for Telegram integration)
             try {
                 const sessionExists = this.db.prepare('SELECT 1 FROM sessions WHERE id = ?').get(sessionId);
                 if (!sessionExists) {
-                    const title = sessionId.startsWith('telegram_') ? `Telegram Chat` : 'New Session';
+                    let title = 'New Session';
+                    if (sessionId.startsWith('telegram_'))
+                        title = 'Telegram Chat';
+                    else if (sessionId.startsWith('discord_'))
+                        title = 'Discord Chat';
                     this.db.prepare('INSERT INTO sessions (id, title) VALUES (?, ?)').run(sessionId, title);
                 }
             }
@@ -294,6 +352,66 @@ class Logger {
         const result = this.db.prepare(`UPDATE limit_orders SET status = 'ACTIVE' WHERE id = ?`).run(orderId);
         return result.changes > 0;
     }
+    // V4: Transaction Persistence Methods
+    savePendingTransaction(tx) {
+        this.db.prepare(`
+      INSERT INTO pending_transactions (id, type, chain_name, details, status, result, nonce, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        status = excluded.status,
+        result = excluded.result,
+        nonce = excluded.nonce
+    `).run(tx.id, tx.type, tx.chainName, JSON.stringify(tx.details), tx.status, tx.result || null, tx.nonce || null, tx.createdAt || Date.now());
+    }
+    getPendingTransactions() {
+        const rows = this.db.prepare(`SELECT * FROM pending_transactions WHERE status = 'pending'`).all();
+        return rows.map(r => ({
+            id: r.id,
+            type: r.type,
+            chainName: r.chain_name,
+            details: JSON.parse(r.details),
+            status: r.status,
+            result: r.result,
+            nonce: r.nonce,
+            createdAt: r.created_at
+        }));
+    }
+    getTransaction(id) {
+        const r = this.db.prepare(`SELECT * FROM pending_transactions WHERE id = ?`).get(id);
+        if (!r)
+            return undefined;
+        return {
+            id: r.id,
+            type: r.type,
+            chainName: r.chain_name,
+            details: JSON.parse(r.details),
+            status: r.status,
+            result: r.result,
+            nonce: r.nonce,
+            createdAt: r.created_at
+        };
+    }
+    savePendingWithdrawal(w) {
+        this.db.prepare(`
+      INSERT INTO pending_withdrawals (id, l2_tx_hash, l1_chain, l2_chain, portal_address, user_address, amount, status, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET status = excluded.status
+    `).run(w.id, w.l2TxHash, w.l1Chain, w.l2Chain, w.portalAddress, w.userAddress, w.amount, w.status, w.createdAt || Date.now());
+    }
+    getPendingWithdrawals() {
+        const rows = this.db.prepare(`SELECT * FROM pending_withdrawals WHERE status != 'COMPLETED'`).all();
+        return rows.map(r => ({
+            id: r.id,
+            l2TxHash: r.l2_tx_hash,
+            l1Chain: r.l1_chain,
+            l2Chain: r.l2_chain,
+            portalAddress: r.portal_address,
+            userAddress: r.user_address,
+            amount: r.amount,
+            status: r.status,
+            createdAt: r.created_at
+        }));
+    }
 }
 exports.Logger = Logger;
 exports.logger = new Logger();

package/dist/packages/core/src/memory/promotionEngine.js

@@ -38,18 +38,31 @@ class PromotionEngine {
             // Deduplicate arrays
             const uniquePermanent = [...new Set(permanentPreferences)];
             const uniqueRecent = [...new Set(recentObservations)];
-            // 4. Rewrite user.md (The Golden Profile)
-            this.rewriteUserProfile(uniquePermanent, uniqueRecent);
+            // 4. Fetch Persona Traits
+            const personas = episodic_1.episodicDB.getStrongPersonas(0.4);
+            const personaStrings = [];
+            for (const p of personas) {
+                personaStrings.push(`- [${p.category.toUpperCase()}] ${p.trait}`);
+            }
+            // 5. Rewrite user.md (The Golden Profile)
+            this.rewriteUserProfile(uniquePermanent, uniqueRecent, personaStrings);
         }
         catch (error) {
             console.error('[PromotionEngine] Error running promotion engine:', error);
         }
     }
-    static rewriteUserProfile(permanent, recent) {
+    static rewriteUserProfile(permanent, recent, personas = []) {
         const userMdPath = (0, paths_1.getPath)('user.md');
         let newContent = `Write custom instructions, special rules, user profiles, or the persona you want for Nyxora AI in this file.\n\n`;
         newContent += `<!-- AUTOMANAGED BY PROMOTION ENGINE. MANUAL EDITS MAY BE OVERWRITTEN -->\n\n`;
-        newContent += `# Permanent Preferences\n`;
+        newContent += `# User Persona & Identity\n`;
+        if (personas.length === 0) {
+            newContent += `*(No specific persona traits identified yet)*\n`;
+        }
+        else {
+            newContent += personas.join('\n') + '\n';
+        }
+        newContent += `\n# Permanent Preferences\n`;
         if (permanent.length === 0) {
             newContent += `*(No permanent preferences recorded yet)*\n`;
         }
@@ -64,7 +77,7 @@ class PromotionEngine {
             newContent += recent.join('\n') + '\n';
         }
         fs_1.default.writeFileSync(userMdPath, newContent, 'utf-8');
-        console.log(`[PromotionEngine] user.md successfully synchronized with Layer 2 Episodic Memory.`);
+        console.log(`[PromotionEngine] user.md successfully synchronized with Layer 2 Episodic Memory and Personas.`);
     }
 }
 exports.PromotionEngine = PromotionEngine;

package/dist/packages/core/src/system/agentskills.js

@@ -161,6 +161,16 @@ class AgentSkills {
         if (!fs_1.default.existsSync(scriptPath)) {
             throw new Error(`Execution script not found for skill '${name}' at path: ${scriptPath}`);
         }
+        // Automatically load .env for the skill if it exists
+        const envPath = path_1.default.join(this.skillsDir, name, '.env');
+        if (fs_1.default.existsSync(envPath)) {
+            try {
+                require('dotenv').config({ path: envPath });
+            }
+            catch (e) {
+                console.warn(`[AgentSkills] Failed to load .env for skill '${name}':`, e);
+            }
+        }
         try {
             // Dynamic import of the TS/JS module
             const module = await Promise.resolve(`${scriptPath}`).then(s => __importStar(require(s)));

package/dist/packages/core/src/system/plugins/GoogleWorkspacePlugin.js

@@ -5,7 +5,7 @@ const googleWorkspace_1 = require("../skills/googleWorkspace");
 class GoogleWorkspacePlugin {
     name = 'GoogleWorkspacePlugin';
     description = 'Google Workspace operations including Gmail, Calendar, Docs, and Sheets.';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [
         googleWorkspace_1.readGmailInboxToolDefinition,
         googleWorkspace_1.listCalendarEventsToolDefinition,

package/dist/packages/core/src/system/plugins/SystemCorePlugin.js

@@ -10,7 +10,7 @@ const forgetMemory_1 = require("../skills/forgetMemory");
 class SystemCorePlugin {
     name = 'SystemCorePlugin';
     description = 'Core system identity, profile, and task scheduling operations.';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [
         updateProfile_1.updateProfileToolDefinition,
         updateIdentity_1.updateIdentityToolDefinition,

package/dist/packages/core/src/system/plugins/SystemExternalPlugin.js

@@ -5,7 +5,7 @@ const createAgentSkill_1 = require("../skills/createAgentSkill");
 class SystemExternalPlugin {
     name = 'SystemExternalPlugin';
     description = 'Provides tools for creating and managing third-party external agent skills.';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [
         createAgentSkill_1.createAgentSkillToolDefinition
     ];

package/dist/packages/core/src/system/plugins/SystemPluginInstallerPlugin.js

@@ -25,7 +25,7 @@ const installPluginDefinition = {
 class SystemPluginInstallerPlugin {
     name = 'SystemPluginInstallerPlugin';
     description = 'Autonomous package manager for installing and auto-healing dynamic plugins.';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [installPluginDefinition];
     handlers = {
         ['install_plugin']: async (args) => {

package/dist/packages/core/src/system/plugins/SystemSocialPlugin.js

@@ -6,7 +6,7 @@ const notionWorkspace_1 = require("../skills/notionWorkspace");
 class SystemSocialPlugin {
     name = 'SystemSocialPlugin';
     description = 'Social media and external workspace operations (Twitter, Notion).';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [
         xManager_1.xManagerToolDefinition,
         notionWorkspace_1.notionWorkspaceToolDefinition

package/dist/packages/core/src/system/plugins/SystemWebPlugin.js

@@ -9,7 +9,7 @@ const audioTranscribe_1 = require("../skills/audioTranscribe");
 class SystemWebPlugin {
     name = 'SystemWebPlugin';
     description = 'Web browsing, searching, and media analysis operations.';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [
         browseWeb_1.browseWebsiteToolDefinition,
         searchWeb_1.searchWebToolDefinition,

package/dist/packages/core/src/system/plugins/SystemWorkspacePlugin.js

@@ -11,7 +11,7 @@ const createCognitiveSkill_1 = require("../skills/createCognitiveSkill");
 class SystemWorkspacePlugin {
     name = 'SystemWorkspacePlugin';
     description = 'Local system operations including file management, terminal execution, and Git.';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [
         readFile_1.readLocalFileToolDefinition,
         writeFile_1.writeLocalFileToolDefinition,
@@ -31,8 +31,8 @@ class SystemWorkspacePlugin {
         ['edit_local_file']: async (args) => {
             return await (0, editFile_1.editLocalFile)(args.filePath, args.searchString, args.replacementString);
         },
-        ['generate_excel_report']: async (args) => {
-            return await (0, generateExcel_1.generateExcelFile)(args.data, args.filename);
+        ['generate_excel_file']: async (args) => {
+            return await (0, generateExcel_1.generateExcelFile)(args.data, args.filePath);
         },
         ['run_terminal_command']: async (args) => {
             return await (0, executeShell_1.runTerminalCommand)(args.command);

package/dist/packages/core/src/system/plugins/createSkill.js

@@ -5,7 +5,7 @@ const skillExtractor_1 = require("../skillExtractor");
 const reasoning_1 = require("../../agent/reasoning");
 class CreateSkillPlugin {
     name = 'CreateSkill';
-    version = '1.0.0';
+    version = '1.0.1';
     description = 'Autonomously extracts and creates skills for Nyxora.';
     tools = [
         {

package/dist/packages/core/src/system/skillExtractor.js

@@ -30,11 +30,22 @@ User Intent / Logic: ${userIntent}
 Chat Traces (if any):
 ${historyTraces.join('\n')}
 
-The SKILL.md must contain a YAML frontmatter block with:
-- name: ${safeName}
-- version: 1.0.0
-- description
-- parameters (OpenAI function calling schema format)
+The SKILL.md must contain a YAML frontmatter block exactly following this structure:
+---
+name: ${safeName}
+version: 1.0.0
+description: <Your generated description>
+parameters:
+  type: object
+  properties:
+    param1:
+      type: string
+      description: ...
+  required:
+    - param1
+---
+
+CRITICAL: The 'required' array MUST be indented exactly inside the 'parameters' block as shown above. Do NOT put 'required' at the root level of the YAML.
 
 Do NOT write anything outside the frontmatter except an optional markdown description below it.
 Output ONLY the raw SKILL.md content.`;

package/dist/packages/core/src/system/skills/forgetMemory.js

@@ -23,13 +23,15 @@ exports.forgetMemoryToolDefinition = {
 };
 async function forgetMemory(keyword) {
     try {
-        const changes = episodic_1.episodicDB.deleteMemoryByFact(keyword);
-        if (changes > 0) {
+        const memoryChanges = episodic_1.episodicDB.deleteMemoryByFact(keyword);
+        const personaChanges = episodic_1.episodicDB.deletePersonaByTrait(keyword);
+        const totalChanges = memoryChanges + personaChanges;
+        if (totalChanges > 0) {
             await promotionEngine_1.PromotionEngine.runPromotionAndDecay();
-            return `[Success] Deleted ${changes} memory records containing the keyword '${keyword}'. The user.md profile has been synchronized.`;
+            return `[Success] Deleted ${memoryChanges} memory record(s) and ${personaChanges} persona trait(s) containing '${keyword}'. Profile synchronized.`;
         }
         else {
-            return `[Info] No memories found containing the keyword '${keyword}'.`;
+            return `[Info] No memories or persona traits found containing the keyword '${keyword}'.`;
         }
     }
     catch (error) {