morpheus-cli 0.9.0 → 0.9.1

package/dist/channels/discord.js

@@ -1,4 +1,4 @@
-import { Client, GatewayIntentBits, Partials, Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord.js';
+import { Client, GatewayIntentBits, Partials, Events, ChannelType, REST, Routes, SlashCommandBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, ComponentType, } from 'discord.js';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
@@ -26,6 +26,15 @@ const SLASH_COMMANDS = [
         .setName('newsession')
         .setDescription('Archive current session and start a new one')
         .setDMPermission(true),
+    new SlashCommandBuilder()
+        .setName('sessions')
+        .setDescription('List all sessions and switch between them')
+        .setDMPermission(true),
+    new SlashCommandBuilder()
+        .setName('session_switch')
+        .setDescription('Switch to a specific session')
+        .addStringOption(opt => opt.setName('id').setDescription('Session ID to switch to').setRequired(true))
+        .setDMPermission(true),
     new SlashCommandBuilder()
         .setName('chronos')
         .setDescription('Schedule a prompt for the Oracle')
@@ -103,6 +112,8 @@ export class DiscordAdapter {
     display = DisplayManager.getInstance();
     config = ConfigManager.getInstance();
     history = new SQLiteChatMessageHistory({ sessionId: '' });
+    /** Per-channel session tracking — which session this Discord adapter is currently using */
+    currentSessionId = null;
     telephonist = null;
     telephonistProvider = null;
     telephonistModel = null;
@@ -178,8 +189,8 @@ export class DiscordAdapter {
                 return;
             this.display.log(`${message.author.tag}: ${text}`, { source: 'Discord' });
             try {
-                const sessionId = await this.history.getCurrentSessionOrCreate();
-                await this.oracle.setSessionId(sessionId);
+                const sessionId = this.currentSessionId ?? await this.history.getCurrentSessionOrCreate();
+                this.currentSessionId = sessionId;
                 const response = await this.oracle.chat(text, undefined, false, {
                     origin_channel: 'discord',
                     session_id: sessionId,
@@ -292,8 +303,8 @@ export class DiscordAdapter {
             // Show transcription
             await channel.send(`🎤 "${text}"`);
             // Process with Oracle
-            const sessionId = await this.history.getCurrentSessionOrCreate();
-            await this.oracle.setSessionId(sessionId);
+            const sessionId = this.currentSessionId ?? await this.history.getCurrentSessionOrCreate();
+            this.currentSessionId = sessionId;
             const response = await this.oracle.chat(text, usage, true, {
                 origin_channel: 'discord',
                 session_id: sessionId,
@@ -355,6 +366,12 @@ export class DiscordAdapter {
             case 'newsession':
                 await this.cmdNewSession(interaction);
                 break;
+            case 'sessions':
+                await this.cmdSessions(interaction);
+                break;
+            case 'session_switch':
+                await this.cmdSessionSwitch(interaction);
+                break;
             case 'chronos':
                 await this.cmdChronos(interaction);
                 break;
@@ -407,6 +424,8 @@ export class DiscordAdapter {
             '`/status` — Check Morpheus status',
             '`/stats` — Token usage statistics',
             '`/newsession` — Start a new session',
+            '`/sessions` — List all sessions (switch, archive, delete)',
+            '`/session_switch id:` — Switch to a specific session',
             '',
             '**Chronos (Scheduler)**',
             '`/chronos prompt: time:` — Schedule a job for the Oracle',
@@ -474,14 +493,122 @@ export class DiscordAdapter {
     async cmdNewSession(interaction) {
         try {
             const history = new SQLiteChatMessageHistory({ sessionId: '' });
-            await history.createNewSession();
+            const newSessionId = await history.createNewSession();
             history.close();
+            // Track the new session as the current one for this Discord channel
+            this.currentSessionId = newSessionId;
             await interaction.reply({ content: '✅ New session started.' });
         }
         catch (err) {
             await interaction.reply({ content: `Error: ${err.message}` });
         }
     }
+    async cmdSessions(interaction) {
+        try {
+            const history = new SQLiteChatMessageHistory({ sessionId: '' });
+            const sessions = (await history.listSessions()).filter((s) => !s.id.startsWith('chronos-job-') && !s.id.startsWith('sati-evaluation'));
+            history.close();
+            if (sessions.length === 0) {
+                await interaction.reply({ content: 'No sessions found.' });
+                return;
+            }
+            const lines = ['**Sessions:**\n'];
+            const rows = [];
+            for (const session of sessions) {
+                const title = session.title || 'Untitled Session';
+                const isCurrent = session.id === this.currentSessionId;
+                const icon = isCurrent ? '🟢' : '⚪';
+                const started = new Date(session.started_at).toLocaleString();
+                lines.push(`${icon} **${title}**`);
+                lines.push(`  ID: \`${session.id}\``);
+                lines.push(`  Started: ${started}\n`);
+                // Discord allows max 5 buttons per row, max 5 rows per message
+                if (rows.length < 5) {
+                    const btns = [];
+                    if (!isCurrent) {
+                        btns.push(new ButtonBuilder()
+                            .setCustomId(`session_switch_${session.id}`)
+                            .setLabel('Switch')
+                            .setStyle(ButtonStyle.Primary)
+                            .setEmoji('➡️'));
+                    }
+                    btns.push(new ButtonBuilder()
+                        .setCustomId(`session_archive_${session.id}`)
+                        .setLabel('Archive')
+                        .setStyle(ButtonStyle.Secondary)
+                        .setEmoji('📂'));
+                    btns.push(new ButtonBuilder()
+                        .setCustomId(`session_delete_${session.id}`)
+                        .setLabel('Delete')
+                        .setStyle(ButtonStyle.Danger)
+                        .setEmoji('🗑️'));
+                    rows.push(new ActionRowBuilder().addComponents(...btns));
+                }
+            }
+            const content = lines.join('\n').slice(0, 2000);
+            const reply = await interaction.reply({ content, components: rows, fetchReply: true });
+            // Collect button interactions for 60 seconds
+            const collector = reply.createMessageComponentCollector({
+                componentType: ComponentType.Button,
+                time: 60_000,
+            });
+            collector.on('collect', async (btn) => {
+                try {
+                    if (btn.customId.startsWith('session_switch_')) {
+                        const sid = btn.customId.replace('session_switch_', '');
+                        const h = new SQLiteChatMessageHistory({ sessionId: '' });
+                        await h.switchSession(sid);
+                        h.close();
+                        this.currentSessionId = sid;
+                        await btn.reply({ content: `✅ Switched to session \`${sid}\`.`, ephemeral: true });
+                    }
+                    else if (btn.customId.startsWith('session_archive_')) {
+                        const sid = btn.customId.replace('session_archive_', '');
+                        const h = new SQLiteChatMessageHistory({ sessionId: '' });
+                        await h.archiveSession(sid);
+                        h.close();
+                        if (this.currentSessionId === sid)
+                            this.currentSessionId = null;
+                        await btn.reply({ content: `📂 Session \`${sid}\` archived.`, ephemeral: true });
+                    }
+                    else if (btn.customId.startsWith('session_delete_')) {
+                        const sid = btn.customId.replace('session_delete_', '');
+                        const h = new SQLiteChatMessageHistory({ sessionId: '' });
+                        await h.deleteSession(sid);
+                        h.close();
+                        if (this.currentSessionId === sid)
+                            this.currentSessionId = null;
+                        await btn.reply({ content: `🗑️ Session \`${sid}\` deleted.`, ephemeral: true });
+                    }
+                }
+                catch (err) {
+                    await btn.reply({ content: `Error: ${err.message}`, ephemeral: true }).catch(() => { });
+                }
+            });
+            collector.on('end', async () => {
+                try {
+                    await interaction.editReply({ components: [] });
+                }
+                catch { /* message may have been deleted */ }
+            });
+        }
+        catch (err) {
+            await interaction.reply({ content: `Error: ${err.message}` });
+        }
+    }
+    async cmdSessionSwitch(interaction) {
+        const sessionId = interaction.options.getString('id', true);
+        try {
+            const history = new SQLiteChatMessageHistory({ sessionId: '' });
+            await history.switchSession(sessionId);
+            history.close();
+            this.currentSessionId = sessionId;
+            await interaction.reply({ content: `✅ Switched to session \`${sessionId}\`.` });
+        }
+        catch (err) {
+            await interaction.reply({ content: `Error: ${err.message}` });
+        }
+    }
     async cmdChronos(interaction) {
         const prompt = interaction.options.getString('prompt', true);
         const timeExpr = interaction.options.getString('time', true);

package/dist/channels/telegram.js

@@ -144,6 +144,8 @@ export class TelegramAdapter {
     telephonistProvider = null;
     telephonistModel = null;
     history = new SQLiteChatMessageHistory({ sessionId: '' });
+    /** Per-channel session tracking — which session this Telegram adapter is currently using */
+    currentSessionId = null;
     RATE_LIMIT_MS = 3000; // minimum ms between requests per user
     rateLimiter = new Map(); // userId -> last request timestamp
     // Pending Chronos create confirmations (userId -> job data + expiry)
@@ -230,8 +232,8 @@ export class TelegramAdapter {
                 try {
                     // Send "typing" status
                     await ctx.sendChatAction('typing');
-                    const sessionId = await this.history.getCurrentSessionOrCreate();
-                    await this.oracle.setSessionId(sessionId);
+                    const sessionId = this.currentSessionId ?? await this.history.getCurrentSessionOrCreate();
+                    this.currentSessionId = sessionId;
                     // Process with Agent
                     const response = await this.oracle.chat(text, undefined, false, {
                         origin_channel: 'telegram',
@@ -317,9 +319,9 @@ export class TelegramAdapter {
                     this.display.log(`Transcription success for @${user}: "${text}"`, { source: 'Telephonist', level: 'success' });
                     // Audit: record telephonist execution
                     try {
-                        const sessionId = await this.history.getCurrentSessionOrCreate();
+                        const auditSessionId = this.currentSessionId ?? await this.history.getCurrentSessionOrCreate();
                         AuditRepository.getInstance().insert({
-                            session_id: sessionId,
+                            session_id: auditSessionId,
                             event_type: 'telephonist',
                             agent: 'telephonist',
                             provider: config.audio.provider,
@@ -345,8 +347,8 @@ export class TelegramAdapter {
                     // So I should treat 'text' as if it was a text message.
                     await ctx.reply(`🎤 Transcription: "${text}"`);
                     await ctx.sendChatAction('typing');
-                    const sessionId = await this.history.getCurrentSessionOrCreate();
-                    await this.oracle.setSessionId(sessionId);
+                    const sessionId = this.currentSessionId ?? await this.history.getCurrentSessionOrCreate();
+                    this.currentSessionId = sessionId;
                     // Process with Agent
                     const response = await this.oracle.chat(text, usage, true, {
                         origin_channel: 'telegram',
@@ -380,9 +382,9 @@ export class TelegramAdapter {
                     const detail = error?.cause?.message || error?.response?.data?.error?.message || error.message;
                     this.display.log(`Audio processing error for @${user}: ${detail}`, { source: 'Telephonist', level: 'error' });
                     try {
-                        const sessionId = await this.history.getCurrentSessionOrCreate();
+                        const auditSessionId = this.currentSessionId ?? 'default';
                         AuditRepository.getInstance().insert({
-                            session_id: sessionId,
+                            session_id: auditSessionId,
                             event_type: 'telephonist',
                             agent: 'telephonist',
                             provider: this.config.get().audio.provider,
@@ -428,12 +430,14 @@ export class TelegramAdapter {
                     return;
                 }
                 try {
-                    // Obter a sessão atual antes de alternar
+                    // Validate session exists and is usable
                     const history = new SQLiteChatMessageHistory({ sessionId: "" });
-                    // Alternar para a nova sessão
                     await history.switchSession(sessionId);
+                    history.close();
+                    // Track this session as the current one for this Telegram channel
+                    this.currentSessionId = sessionId;
                     await ctx.answerCbQuery();
-                    // Remover a mensagem anterior e enviar confirmação
+                    // Remove the previous message and send confirmation
                     if (ctx.updateType === 'callback_query') {
                         ctx.deleteMessage().catch(() => { });
                     }
@@ -1154,7 +1158,10 @@ export class TelegramAdapter {
     async handleApproveNewSessionCommand(ctx, user) {
         try {
             const history = new SQLiteChatMessageHistory({ sessionId: "" });
-            await history.createNewSession();
+            const newSessionId = await history.createNewSession();
+            history.close();
+            // Track the new session as the current one for this Telegram channel
+            this.currentSessionId = newSessionId;
         }
         catch (e) {
             await ctx.reply(`Error creating new session: ${e.message}`);
@@ -1167,21 +1174,20 @@ export class TelegramAdapter {
             // callback_data limit and they are not user-managed sessions.
             const sessions = (await history.listSessions()).filter((s) => !s.id.startsWith('chronos-job-') && !s.id.startsWith('sati-evaluation'));
             if (sessions.length === 0) {
-                await ctx.reply('No active or paused sessions found\\.', { parse_mode: 'MarkdownV2' });
+                await ctx.reply('No sessions found\\.', { parse_mode: 'MarkdownV2' });
                 return;
             }
             let response = '*Sessions:*\n\n';
             const keyboard = [];
             for (const session of sessions) {
                 const title = session.title || 'Untitled Session';
-                const statusEmoji = session.status === 'active' ? '🟢' : '🟡';
+                const isCurrent = session.id === this.currentSessionId;
+                const statusEmoji = isCurrent ? '🟢' : '⚪';
                 response += `${statusEmoji} *${escMdRaw(title)}*\n`;
                 response += `\\- ID: \`${escMdRaw(session.id)}\`\n`;
-                response += `\\- Status: ${escMdRaw(session.status)}\n`;
                 response += `\\- Started: ${escMdRaw(new Date(session.started_at).toLocaleString())}\n\n`;
-                // Adicionar botão inline para alternar para esta sessão
                 const sessionButtons = [];
-                if (session.status !== 'active') {
+                if (!isCurrent) {
                     sessionButtons.push({
                         text: `➡️ Switch`,
                         callback_data: `switch_session_${session.id}`

package/dist/http/api.js

@@ -61,8 +61,7 @@ export function createApiRouter(oracle, chronosWorker) {
     });
     router.post('/sessions', async (req, res) => {
         try {
-            await history.createNewSession();
-            const newSessionId = await history.getCurrentSessionOrCreate(); // Should be the new one
+            const newSessionId = await history.createNewSession();
             res.json({ success: true, id: newSessionId, message: 'New session started' });
         }
         catch (err) {
@@ -248,7 +247,7 @@ export function createApiRouter(oracle, chronosWorker) {
         }
         try {
             const { message, sessionId } = parsed.data;
-            await oracle.setSessionId(sessionId);
+            // Session is passed via taskContext — no need to mutate global Oracle state.
             const response = await oracle.chat(message, undefined, false, {
                 origin_channel: 'ui',
                 session_id: sessionId,

package/dist/runtime/apoc.js

@@ -259,7 +259,7 @@ ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
         try {
             const inputCount = messages.length;
             const startMs = Date.now();
-            const response = await this.agent.invoke({ messages }, { recursionLimit: 100 });
+            const response = await this.agent.invoke({ messages }, { recursionLimit: 50 });
             const durationMs = Date.now() - startMs;
             const apocConfig = this.config.apoc || this.config.llm;
             const lastMessage = response.messages[response.messages.length - 1];

package/dist/runtime/keymaker.js

@@ -117,7 +117,7 @@ CRITICAL — NEVER FABRICATE DATA:
                 origin_user_id: taskContext?.origin_user_id,
             };
             const startMs = Date.now();
-            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 100 }));
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 50 }));
             const durationMs = Date.now() - startMs;
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"

package/dist/runtime/memory/sati/service.js

@@ -97,7 +97,7 @@ export class SatiService {
                 console.warn('[SatiService] Failed to persist input log:', e);
             }
             const satiStartMs = Date.now();
-            const response = await agent.invoke({ messages }, { recursionLimit: 100 });
+            const response = await agent.invoke({ messages }, { recursionLimit: 50 });
             const satiDurationMs = Date.now() - satiStartMs;
             const lastMessage = response.messages[response.messages.length - 1];
             let content = lastMessage.content.toString();

package/dist/runtime/memory/sqlite.js

@@ -716,36 +716,19 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     }
     async createNewSession() {
         const now = Date.now();
-        // Transação para garantir consistência
-        const tx = this.db.transaction(() => {
-            // Pegar a sessão atualmente ativa
-            const activeSession = this.db.prepare(`
-        SELECT id FROM sessions
-        WHERE status = 'active'
-      `).get();
-            // Se houver uma sessão ativa, mudar seu status para 'paused'
-            if (activeSession) {
-                this.db.prepare(`
-          UPDATE sessions
-          SET status = 'paused'
-          WHERE id = ?
-        `).run(activeSession.id);
-            }
-            // Criar uma nova sessão ativa
-            const newId = randomUUID();
-            this.db.prepare(`
-        INSERT INTO sessions (
-          id,
-          started_at,
-          status
-        ) VALUES (?, ?, 'active')
-      `).run(newId, now);
-            // Atualizar o ID da sessão atual desta instância
-            this.sessionId = newId;
-            this.titleSet = false; // reset cache for new session
-        });
-        tx(); // Executar a transação
-        this.display.log('✅ Nova sessão iniciada e sessão anterior pausada', { source: 'Sati' });
+        const newId = randomUUID();
+        this.db.prepare(`
+      INSERT INTO sessions (
+        id,
+        started_at,
+        status
+      ) VALUES (?, ?, 'active')
+    `).run(newId, now);
+        // Update this instance to point to the new session
+        this.sessionId = newId;
+        this.titleSet = false;
+        this.display.log('✅ New session created', { source: 'Sati' });
+        return newId;
     }
     chunkText(text, chunkSize = 500, overlap = 50) {
         if (!text || text.length === 0)
@@ -890,27 +873,6 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
       `).run(now, sessionId);
         });
         tx(); // Executar a transação
-        // Se a sessão era active, verificar se há outra para ativar
-        if (session.status === 'active') {
-            const nextSession = this.db.prepare(`
-        SELECT id FROM sessions
-        WHERE status = 'paused'
-        ORDER BY started_at DESC
-        LIMIT 1
-      `).get();
-            if (nextSession) {
-                // Promover a próxima sessão a ativa
-                this.db.prepare(`
-          UPDATE sessions
-          SET status = 'active'
-          WHERE id = ?
-        `).run(nextSession.id);
-            }
-            else {
-                // Nenhuma outra sessão, criar nova
-                this.createFreshSession();
-            }
-        }
     }
     /**
      * Renomear uma sessão ativa ou pausada.
@@ -941,101 +903,46 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         tx(); // Executar a transação
     }
     /**
-     * Trocar o contexto ativo entre sessões não finalizadas.
-     * Validar sessão alvo: existe e status ∈ (paused, active).
-     * Se já for active, não faz nada.
-     * Transação: sessão atual active → paused, sessão alvo → active.
-     */
-    /**
-     * Creates a session row with status 'paused' if it doesn't already exist.
+     * Creates a session row with status 'active' if it doesn't already exist.
      * Safe to call multiple times — idempotent.
      */
     ensureSession(sessionId) {
         const existing = this.db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId);
         if (!existing) {
-            this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'paused')").run(sessionId, Date.now());
+            this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'active')").run(sessionId, Date.now());
         }
     }
+    /**
+     * Validates that the target session exists and is usable (not archived/deleted).
+     * No longer swaps active↔paused — sessions are independently usable from any channel.
+     */
     async switchSession(targetSessionId) {
-        // Validar sessão alvo: existe e status ∈ (paused, active)
         const targetSession = this.db.prepare(`
       SELECT id, status FROM sessions
       WHERE id = ?
     `).get(targetSessionId);
         if (!targetSession) {
-            throw new Error(`Sessão alvo com ID ${targetSessionId} não encontrada.`);
+            throw new Error(`Session with ID ${targetSessionId} not found.`);
         }
-        if (targetSession.status !== 'active' && targetSession.status !== 'paused') {
-            throw new Error(`Sessão alvo com ID ${targetSessionId} não está em estado ativo ou pausado. Status atual: ${targetSession.status}`);
+        if (targetSession.status === 'archived' || targetSession.status === 'deleted') {
+            throw new Error(`Session ${targetSessionId} is ${targetSession.status} and cannot be used.`);
         }
-        // Se já for active, não faz nada
-        if (targetSession.status === 'active') {
-            return; // A sessão alvo já está ativa, não precisa fazer nada
-        }
-        // Transação: sessão atual active → paused, sessão alvo → active
-        const tx = this.db.transaction(() => {
-            // Pegar a sessão atualmente ativa
-            const currentActiveSession = this.db.prepare(`
-        SELECT id FROM sessions
-        WHERE status = 'active'
-      `).get();
-            // Se houver uma sessão ativa, mudar seu status para 'paused'
-            if (currentActiveSession) {
-                this.db.prepare(`
-          UPDATE sessions
-          SET status = 'paused'
-          WHERE id = ?
-        `).run(currentActiveSession.id);
-            }
-            // Mudar o status da sessão alvo para 'active'
-            this.db.prepare(`
-        UPDATE sessions
-        SET status = 'active'
-        WHERE id = ?
-      `).run(targetSessionId);
-        });
-        tx(); // Executar a transação
     }
     /**
-     * Garantir que sempre exista uma sessão ativa válida.
-     * Buscar sessão com status = 'active', retornar seu id se existir,
-     * ou criar nova sessão (createFreshSession) e retornar o novo id.
+     * Returns the most recently created usable session, or creates one if none exist.
+     * A session is usable if its status is 'active' or 'paused' (both are equivalent post-refactor).
      */
     async getCurrentSessionOrCreate() {
-        // Buscar sessão com status = 'active'
-        const activeSession = this.db.prepare(`
-      SELECT id FROM sessions
-      WHERE status = 'active'
-    `).get();
-        if (activeSession) {
-            // Se existir, retornar seu id
-            return activeSession.id;
-        }
-        else {
-            // Se não existir, criar nova sessão (createFreshSession) e retornar o novo id
-            const newId = await this.createFreshSession();
-            return newId;
-        }
-    }
-    async createFreshSession() {
-        // Validar que não existe sessão 'active'
-        const activeSession = this.db.prepare(`
+        const session = this.db.prepare(`
       SELECT id FROM sessions
-      WHERE status = 'active'
+      WHERE status IN ('active', 'paused')
+      ORDER BY started_at DESC
+      LIMIT 1
     `).get();
-        if (activeSession) {
-            throw new Error('Já existe uma sessão ativa. Não é possível criar uma nova sessão ativa.');
+        if (session) {
+            return session.id;
         }
-        const now = Date.now();
-        const newId = randomUUID();
-        this.db.prepare(`
-    INSERT INTO sessions (
-      id,
-      started_at,
-      status
-    ) VALUES (?, ?, 'active')
-  `).run(newId, now);
-        return newId;
+        return this.createNewSession();
     }
     /**
      * Lists all active and paused sessions with their basic information.

package/dist/runtime/neo.js

@@ -137,7 +137,7 @@ ${context ? `Context:\n${context}` : ""}
             };
             const inputCount = messages.length;
             const startMs = Date.now();
-            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 100 }));
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 50 }));
             const durationMs = Date.now() - startMs;
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"