nyxora 26.7.2 → 26.7.4

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', reply_parameters: { message_id: ctx.message.message_id } });
                     }
                     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;
+                }
+            };
+            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', reply_parameters: { message_id: ctx.message.message_id } });
+                    }
+                    catch { }
+                    isDrafting = false;
                 }
-                // Transactions will now use conversational approval (Zero-Latency text prompts) instead of InlineKeyboards.
-                await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML' });
+            };
+            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, reply_parameters: { message_id: ctx.message.message_id } }).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.', { reply_parameters: { message_id: ctx.message.message_id } }).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) => {
@@ -159,7 +253,7 @@ function startTelegramBot() {
                 const onProgress = async (progressText) => {
                     try {
                         if (!progressMsgId) {
-                            const sent = await ctx.reply(`<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML' });
+                            const sent = await ctx.reply(`<i>${progressText.replace(/_/g, '')}</i>`, { parse_mode: 'HTML', reply_parameters: { message_id: ctx.message?.message_id } });
                             progressMsgId = sent.message_id;
                         }
                         else {
@@ -172,18 +266,20 @@ function startTelegramBot() {
                 if (progressMsgId) {
                     await ctx.api.deleteMessage(ctx.chat.id, progressMsgId).catch(() => { });
                 }
-                await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML' });
+                await ctx.reply(formatToTelegramHTML(response), { parse_mode: 'HTML', reply_parameters: { message_id: ctx.message?.message_id } });
             }
             catch (error) {
                 console.error('[Telegram] Error processing document:', error);
-                await ctx.reply('❌ Sorry, I failed to download or analyze the document.');
+                await ctx.reply('❌ Sorry, I failed to download or analyze the document.', { reply_parameters: { message_id: ctx.message?.message_id } });
             }
         });
         // Transaction approval and rejection are now handled conversationally via the LLM and the confirm_pending_tx tool.
         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,55 @@ 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);
+        try {
+            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);
+            }
+        }
+        catch (e) {
+            // Handle UNIQUE constraint collision if the trait already exists in the database (e.g. from an older version with category 'general')
+            if (e.message && e.message.includes('UNIQUE constraint failed')) {
+                this.db.prepare('UPDATE user_personas SET category = ?, confidence = ?, source = ?, lastUpdated = CURRENT_TIMESTAMP WHERE trait = ?').run(category, confidence, source, value.trim());
+            }
+            else {
+                throw e;
+            }
         }
     }
     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,13 +5,15 @@ 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,
         googleWorkspace_1.appendRowToSheetsToolDefinition,
         googleWorkspace_1.readGoogleDocsToolDefinition,
-        googleWorkspace_1.readGoogleFormResponsesToolDefinition
+        googleWorkspace_1.readGoogleFormResponsesToolDefinition,
+        googleWorkspace_1.sendEmailToolDefinition,
+        googleWorkspace_1.addCalendarEventToolDefinition
     ];
     handlers = {
         ['read_gmail_inbox']: async (args) => {
@@ -28,6 +30,12 @@ class GoogleWorkspacePlugin {
         },
         ['read_google_form_responses']: async (args) => {
             return await (0, googleWorkspace_1.readGoogleFormResponses)(args.formId);
+        },
+        ['send_email']: async (args) => {
+            return await (0, googleWorkspace_1.sendEmail)(args.to, args.subject, args.body);
+        },
+        ['add_calendar_event']: async (args) => {
+            return await (0, googleWorkspace_1.addCalendarEvent)(args.summary, args.description, args.startTime, args.endTime);
         }
     };
 }

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 = [
         {