morpheus-cli 0.9.0 → 0.9.3

package/README.md

@@ -266,6 +266,13 @@ Telegram responses use rich HTML formatting conversion with:
 
 Task results are delivered proactively with metadata (task id, agent, status) and output/error body.
 
+**Session commands:**
+- `/session` — Show current session info
+- `/session list` — List recent sessions
+- `/session new` — Create new session
+- `/session switch <id>` — Switch to existing session
+- `/session rename <name>` — Rename current session
+
 **Voice messages:** Telegram voice messages are automatically transcribed (Gemini / Whisper / OpenRouter) and processed as text through the Oracle.
 
 ## Discord Experience
@@ -279,7 +286,11 @@ Discord bot responds to **DMs only** from authorized user IDs (`allowedUsers`).
 | `/help` | Show available commands |
 | `/status` | Check Morpheus status |
 | `/stats` | Token usage statistics |
-| `/newsession` | Start a new session |
+| `/session` | Show current session info |
+| `/session_list` | List recent sessions |
+| `/session_new` | Start a new session |
+| `/session_switch id:` | Switch to existing session |
+| `/session_rename name:` | Rename current session |
 | `/mcps` | List MCP servers with tool counts |
 | `/mcpreload` | Reload MCP connections and tools |
 | `/mcp_enable name:` | Enable an MCP server |
@@ -314,16 +325,19 @@ Adding a new channel requires only implementing `IChannelAdapter` (`channel`, `s
 ## Web UI
 
 The dashboard includes:
-- Chat with session management
-- Tasks page (stats, filters, details, retry)
+- Chat with session management and browser notifications
+- Tasks page (stats, filters, details, retry, pagination)
 - Agent settings (Oracle/Sati/Neo/Apoc/Trinity/Smiths)
 - MCP manager (add/edit/delete/toggle/reload)
-- Sati memories (search, bulk delete)
+- Sati memories (search, bulk delete, pagination)
 - Usage stats and model pricing
 - Trinity databases (register/test/refresh schema)
 - Chronos scheduler (create/edit/delete jobs, execution history)
+- Smiths management (add/edit/delete, real-time status, ping)
+- Audit dashboard (session audit, tool call tracking, cost breakdowns)
 - Webhooks and notification inbox
 - Logs viewer
+- Danger Zone (Settings → reset sessions, tasks, jobs, audit, or factory reset)
 
 Chat-specific rendering:
 - AI messages rendered as markdown

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/config/manager.js

@@ -328,6 +328,10 @@ export class ConfigManager {
                 entries: config.smiths?.entries ?? [],
             },
             verbose_mode: resolveBoolean('MORPHEUS_VERBOSE_MODE', config.verbose_mode, true),
+            setup: {
+                enabled: resolveBoolean('MORPHEUS_SETUP_ENABLED', config.setup?.enabled, true),
+                fields: config.setup?.fields ?? ['name', 'timezone', 'preferred_language'],
+            },
         };
     }
     get() {
@@ -411,6 +415,13 @@ export class ConfigManager {
         }
         return defaults;
     }
+    getSetupConfig() {
+        const defaults = { enabled: true, fields: ['name', 'timezone', 'preferred_language'] };
+        if (this.config.setup) {
+            return { ...defaults, ...this.config.setup };
+        }
+        return defaults;
+    }
     getSmithsConfig() {
         const defaults = {
             enabled: false,

package/dist/config/schemas.js

@@ -63,6 +63,10 @@ export const SmithEntrySchema = z.object({
     auth_token: z.string().min(1),
     tls: z.boolean().default(false),
 });
+export const SetupConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    fields: z.array(z.string()).default(['name', 'timezone', 'preferred_language']),
+});
 export const SmithsConfigSchema = z.object({
     enabled: z.boolean().default(false),
     execution_mode: z.enum(['sync', 'async']).default('async'),
@@ -96,6 +100,7 @@ export const ConfigSchema = z.object({
     chronos: ChronosConfigSchema.optional(),
     devkit: DevKitConfigSchema.optional(),
     smiths: SmithsConfigSchema.optional(),
+    setup: SetupConfigSchema.optional(),
     verbose_mode: z.boolean().default(true),
     channels: z.object({
         telegram: z.object({

package/dist/http/api.js

@@ -20,6 +20,7 @@ import { ChronosWorker } from '../runtime/chronos/worker.js';
 import { createChronosJobRouter, createChronosConfigRouter } from './routers/chronos.js';
 import { createSkillsRouter } from './routers/skills.js';
 import { createSmithsRouter } from './routers/smiths.js';
+import { createDangerRouter } from './routers/danger.js';
 import { getActiveEnvOverrides } from '../config/precedence.js';
 import { hotReloadConfig, getRestartRequiredChanges } from '../runtime/hot-reload.js';
 import { AuditRepository } from '../runtime/audit/repository.js';
@@ -49,6 +50,8 @@ export function createApiRouter(oracle, chronosWorker) {
     router.use('/skills', createSkillsRouter());
     // Mount Smiths router
     router.use('/smiths', createSmithsRouter());
+    // Mount Danger Zone router
+    router.use('/danger', createDangerRouter());
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {
@@ -61,8 +64,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 +250,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/http/routers/danger.js

@@ -0,0 +1,137 @@
+import { Router } from 'express';
+import Database from 'better-sqlite3';
+import path from 'path';
+import { homedir } from 'os';
+import fs from 'fs-extra';
+import { z } from 'zod';
+import { SatiRepository } from '../../runtime/memory/sati/repository.js';
+import { DisplayManager } from '../../runtime/display.js';
+/**
+ * Valid categories the user can choose to delete.
+ */
+const VALID_CATEGORIES = [
+    'sessions', // sessions + messages
+    'memories', // sati-memory.db (long-term memory, embeddings, session chunks)
+    'tasks', // background tasks
+    'audit', // audit_events
+    'chronos', // chronos_jobs + chronos_executions
+    'webhooks', // webhooks + webhook_notifications
+];
+const ResetBodySchema = z.object({
+    categories: z.array(z.enum(VALID_CATEGORIES)).min(1, 'At least one category must be selected'),
+});
+/**
+ * Creates the Danger Zone API router.
+ * Provides destructive operations for resetting user data.
+ */
+export function createDangerRouter() {
+    const router = Router();
+    const display = DisplayManager.getInstance();
+    /**
+     * GET /api/danger/categories — List available reset categories
+     */
+    router.get('/categories', (_req, res) => {
+        res.json({
+            categories: VALID_CATEGORIES.map((id) => ({ id })),
+        });
+    });
+    /**
+     * DELETE /api/danger/reset — Purge selected user data
+     *
+     * Body: { categories: ['sessions', 'memories', 'tasks', 'audit', 'chronos', 'webhooks'] }
+     */
+    router.delete('/reset', async (req, res) => {
+        // Validate body
+        const parsed = ResetBodySchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({
+                error: 'Invalid request',
+                details: parsed.error.issues.map((i) => i.message),
+            });
+        }
+        const { categories } = parsed.data;
+        try {
+            const memoryDir = path.join(homedir(), '.morpheus', 'memory');
+            const shortMemoryPath = path.join(memoryDir, 'short-memory.db');
+            const satiMemoryPath = path.join(memoryDir, 'sati-memory.db');
+            const counts = {};
+            // ─── 1. Purge short-memory.db tables based on selected categories ───
+            const needsShortDb = categories.some((c) => ['sessions', 'tasks', 'audit', 'chronos', 'webhooks'].includes(c));
+            if (needsShortDb && fs.existsSync(shortMemoryPath)) {
+                const db = new Database(shortMemoryPath, { timeout: 5000 });
+                db.pragma('journal_mode = WAL');
+                const transaction = db.transaction(() => {
+                    if (categories.includes('sessions')) {
+                        const msgResult = db.prepare('DELETE FROM messages').run();
+                        counts.messages = msgResult.changes;
+                        const sessResult = db.prepare('DELETE FROM sessions').run();
+                        counts.sessions = sessResult.changes;
+                        // Also clear first-time setup state so onboarding runs again after reset
+                        try {
+                            db.prepare('DELETE FROM setup_state').run();
+                        }
+                        catch {
+                            // Table may not exist on older installations — safe to ignore
+                        }
+                    }
+                    if (categories.includes('tasks')) {
+                        const taskResult = db.prepare('DELETE FROM tasks').run();
+                        counts.tasks = taskResult.changes;
+                    }
+                    if (categories.includes('audit')) {
+                        const auditResult = db.prepare('DELETE FROM audit_events').run();
+                        counts.audit_events = auditResult.changes;
+                    }
+                    if (categories.includes('chronos')) {
+                        const jobsResult = db.prepare('DELETE FROM chronos_jobs').run();
+                        counts.chronos_jobs = jobsResult.changes;
+                        const execResult = db.prepare('DELETE FROM chronos_executions').run();
+                        counts.chronos_executions = execResult.changes;
+                    }
+                    if (categories.includes('webhooks')) {
+                        const notifResult = db.prepare('DELETE FROM webhook_notifications').run();
+                        counts.webhook_notifications = notifResult.changes;
+                        const whResult = db.prepare('DELETE FROM webhooks').run();
+                        counts.webhooks = whResult.changes;
+                    }
+                });
+                transaction();
+                db.close();
+            }
+            // ─── 2. Purge sati-memory.db (close, delete, recreate) ───
+            if (categories.includes('memories')) {
+                const satiRepo = SatiRepository.getInstance();
+                satiRepo.close();
+                if (fs.existsSync(satiMemoryPath)) {
+                    fs.removeSync(satiMemoryPath);
+                    fs.removeSync(satiMemoryPath + '-wal');
+                    fs.removeSync(satiMemoryPath + '-shm');
+                    counts.sati_memory = 1;
+                }
+                // Reinitialize so schema is recreated cleanly
+                satiRepo.initialize();
+            }
+            display.log(`🗑️ Data reset via Danger Zone: [${categories.join(', ')}]`, {
+                source: 'DangerZone',
+                level: 'warning',
+            });
+            res.json({
+                success: true,
+                message: 'Selected data has been reset successfully.',
+                categories,
+                deleted: counts,
+            });
+        }
+        catch (error) {
+            display.log(`❌ Danger Zone reset failed: ${error}`, {
+                source: 'DangerZone',
+                level: 'error',
+            });
+            res.status(500).json({
+                error: 'Failed to reset data',
+                details: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    return router;
+}

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/audit/repository.js

@@ -190,6 +190,7 @@ export class AuditRepository {
         SUM(CASE WHEN ae.event_type = 'mcp_tool'        THEN 1 ELSE 0 END) as mcpToolCount,
         SUM(CASE WHEN ae.event_type = 'skill_executed'  THEN 1 ELSE 0 END) as skillCount,
         SUM(CASE WHEN ae.event_type = 'memory_recovery' THEN 1 ELSE 0 END) as memoryRecoveryCount,
+        SUM(CASE WHEN ae.event_type = 'memory_persist'  THEN 1 ELSE 0 END) as memoryPersistCount,
         SUM(CASE WHEN ae.event_type = 'chronos_job'     THEN 1 ELSE 0 END) as chronosJobCount,
         SUM(CASE WHEN ae.event_type = 'task_created'    THEN 1 ELSE 0 END) as taskCreatedCount,
         SUM(CASE WHEN ae.event_type = 'task_completed'  THEN 1 ELSE 0 END) as taskCompletedCount,
@@ -304,6 +305,7 @@ export class AuditRepository {
                 mcpToolCount: totalsRow?.mcpToolCount ?? 0,
                 skillCount: totalsRow?.skillCount ?? 0,
                 memoryRecoveryCount: totalsRow?.memoryRecoveryCount ?? 0,
+                memoryPersistCount: totalsRow?.memoryPersistCount ?? 0,
                 chronosJobCount: totalsRow?.chronosJobCount ?? 0,
                 taskCreatedCount: totalsRow?.taskCreatedCount ?? 0,
                 taskCompletedCount: totalsRow?.taskCompletedCount ?? 0,

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/index.js

@@ -65,7 +65,7 @@ export class SatiMemoryMiddleware {
     async afterAgent(generatedResponse, history, userSessionId) {
         try {
             await this.service.evaluateAndPersist([
-                ...history.slice(-5).map(m => ({
+                ...history.map(m => ({
                     role: m._getType() === 'human' ? 'user' : 'assistant',
                     content: m.content.toString()
                 })),