morpheus-cli 0.9.22 → 0.9.24

package/dist/channels/discord.js

@@ -308,7 +308,9 @@ export class DiscordAdapter {
             filePath = await this.downloadAudioToTemp(attachment.url, contentType);
             // Transcribe
             this.display.log(`Transcribing audio for ${message.author.tag}...`, { source: 'Telephonist' });
+            this.display.startActivity('telephonist', 'Transcribing audio...');
             const { text, usage } = await this.telephonist.transcribe(filePath, contentType, apiKey);
+            this.display.endActivity('telephonist', true);
             this.display.log(`Transcription for ${message.author.tag}: "${text}"`, { source: 'Telephonist', level: 'success' });
             // Show transcription
             await channel.send(`🎤 "${text}"`);
@@ -326,6 +328,7 @@ export class DiscordAdapter {
                     let ttsFilePath = null;
                     const ttsStart = Date.now();
                     try {
+                        this.display.startActivity('telephonist', 'Synthesizing TTS...');
                         const ttsApiKey = getUsableApiKey(ttsConfig.apiKey) ||
                             getUsableApiKey(config.audio.apiKey) ||
                             (config.llm.provider === (ttsConfig.provider === 'google' ? 'gemini' : ttsConfig.provider)
@@ -333,6 +336,7 @@ export class DiscordAdapter {
                         const ttsResult = await this.ttsTelephonist.synthesize(response, ttsApiKey || '', ttsConfig.voice, ttsConfig.style_prompt);
                         ttsFilePath = ttsResult.filePath;
                         const ttsDurationMs = Date.now() - ttsStart;
+                        this.display.endActivity('telephonist', true);
                         const attachment = new AttachmentBuilder(ttsFilePath, { name: 'response.ogg' });
                         await channel.send({ files: [attachment] });
                         this.display.log(`Responded to ${message.author.tag} (TTS audio)`, { source: 'Discord' });
@@ -362,6 +366,7 @@ export class DiscordAdapter {
                         }
                     }
                     catch (ttsError) {
+                        this.display.endActivity('telephonist', false);
                         const ttsDetail = ttsError?.message || String(ttsError);
                         this.display.log(`TTS synthesis failed for ${message.author.tag}: ${ttsDetail} — falling back to text`, { source: 'Telephonist', level: 'warning' });
                         // Audit TTS failure

package/dist/channels/telegram.js

@@ -352,9 +352,11 @@ export class TelegramAdapter {
                     filePath = await this.downloadToTemp(fileLink);
                     // Transcribe
                     this.display.log(`Transcribing audio for @${user}...`, { source: 'Telephonist' });
+                    this.display.startActivity('telephonist', 'Transcribing audio...');
                     const transcribeStart = Date.now();
                     const { text, usage } = await this.telephonist.transcribe(filePath, 'audio/ogg', apiKey);
                     const transcribeDurationMs = Date.now() - transcribeStart;
+                    this.display.endActivity('telephonist', true);
                     this.display.log(`Transcription success for @${user}: "${text}"`, { source: 'Telephonist', level: 'success' });
                     // Audit: record telephonist execution
                     try {
@@ -408,6 +410,7 @@ export class TelegramAdapter {
                             let ttsFilePath = null;
                             const ttsStart = Date.now();
                             try {
+                                this.display.startActivity('telephonist', 'Synthesizing TTS...');
                                 const ttsApiKey = getUsableApiKey(ttsConfig.apiKey) ||
                                     getUsableApiKey(config.audio.apiKey) ||
                                     (config.llm.provider === (ttsConfig.provider === 'google' ? 'gemini' : ttsConfig.provider)
@@ -415,6 +418,7 @@ export class TelegramAdapter {
                                 const ttsResult = await this.ttsTelephonist.synthesize(response, ttsApiKey || '', ttsConfig.voice, ttsConfig.style_prompt);
                                 ttsFilePath = ttsResult.filePath;
                                 const ttsDurationMs = Date.now() - ttsStart;
+                                this.display.endActivity('telephonist', true);
                                 // OGG/Opus → replyWithVoice; everything else (mp3, wav) → replyWithAudio
                                 const isOgg = ttsResult.mimeType.includes('ogg') || ttsResult.mimeType.includes('opus');
                                 if (isOgg) {
@@ -450,6 +454,7 @@ export class TelegramAdapter {
                                 }
                             }
                             catch (ttsError) {
+                                this.display.endActivity('telephonist', false);
                                 const ttsDetail = ttsError?.message || String(ttsError);
                                 this.display.log(`TTS synthesis failed for @${user}: ${ttsDetail} — falling back to text`, { source: 'Telephonist', level: 'warning' });
                                 // Audit TTS failure

package/dist/cli/commands/restart.js

@@ -17,6 +17,12 @@ import { TaskWorker } from '../../runtime/tasks/worker.js';
 import { TaskNotifier } from '../../runtime/tasks/notifier.js';
 import { Link } from '../../runtime/subagents/link/link.js';
 import { LinkWorker } from '../../runtime/subagents/link/worker.js';
+import { ServiceContainer, SERVICE_KEYS } from '../../runtime/container.js';
+import { ChannelNotifierAdapter } from '../../runtime/adapters/ChannelNotifierAdapter.js';
+import { SQLiteTaskEnqueuerAdapter } from '../../runtime/adapters/SQLiteTaskEnqueuerAdapter.js';
+import { SQLiteChatHistoryAdapter } from '../../runtime/adapters/SQLiteChatHistoryAdapter.js';
+import { LangChainProviderAdapter } from '../../runtime/adapters/LangChainProviderAdapter.js';
+import { AuditRepositoryAdapter } from '../../runtime/adapters/AuditRepositoryAdapter.js';
 export const restartCommand = new Command('restart')
     .description('Restart the Morpheus agent')
     .option('--ui', 'Enable web UI', true)
@@ -67,6 +73,15 @@ export const restartCommand = new Command('restart')
         const config = await configManager.load();
         // Initialize persistent logging
         await display.initialize(config.logging);
+        // ── Composition Root ─────────────────────────────────────────────────────
+        // Register port adapters in the ServiceContainer so consumers can
+        // depend on interfaces instead of concrete implementations.
+        ServiceContainer.register(SERVICE_KEYS.notifier, new ChannelNotifierAdapter());
+        ServiceContainer.register(SERVICE_KEYS.taskEnqueuer, new SQLiteTaskEnqueuerAdapter());
+        ServiceContainer.register(SERVICE_KEYS.chatHistory, new SQLiteChatHistoryAdapter());
+        ServiceContainer.register(SERVICE_KEYS.providerFactory, new LangChainProviderAdapter());
+        ServiceContainer.register(SERVICE_KEYS.auditEmitter, new AuditRepositoryAdapter());
+        // ─────────────────────────────────────────────────────────────────────────
         display.log(chalk.green(`Morpheus Agent (${config.agent.name}) starting...`), { source: 'Zaion' });
         display.log(chalk.gray(`PID: ${process.pid}`), { source: 'Zaion' });
         if (options.ui) {

package/dist/cli/commands/start.js

@@ -133,6 +133,15 @@ export const startCommand = new Command('start')
         const config = await configManager.load();
         // Initialize persistent logging
         await display.initialize(config.logging);
+        // ── Composition Root ─────────────────────────────────────────────────────
+        // Register port adapters in the ServiceContainer so consumers can
+        // depend on interfaces instead of concrete implementations.
+        ServiceContainer.register(SERVICE_KEYS.notifier, new ChannelNotifierAdapter());
+        ServiceContainer.register(SERVICE_KEYS.taskEnqueuer, new SQLiteTaskEnqueuerAdapter());
+        ServiceContainer.register(SERVICE_KEYS.chatHistory, new SQLiteChatHistoryAdapter());
+        ServiceContainer.register(SERVICE_KEYS.providerFactory, new LangChainProviderAdapter());
+        ServiceContainer.register(SERVICE_KEYS.auditEmitter, new AuditRepositoryAdapter());
+        // ─────────────────────────────────────────────────────────────────────────
         display.log(chalk.green(`Morpheus Agent (${config.agent.name}) starting...`));
         display.log(chalk.gray(`PID: ${process.pid}`));
         if (options.ui) {
@@ -220,15 +229,6 @@ export const startCommand = new Command('start')
             await clearPid();
             process.exit(1);
         }
-        // ── Composition Root ─────────────────────────────────────────────────────
-        // Register port adapters in the ServiceContainer so consumers can
-        // depend on interfaces instead of concrete implementations.
-        ServiceContainer.register(SERVICE_KEYS.notifier, new ChannelNotifierAdapter());
-        ServiceContainer.register(SERVICE_KEYS.taskEnqueuer, new SQLiteTaskEnqueuerAdapter());
-        ServiceContainer.register(SERVICE_KEYS.chatHistory, new SQLiteChatHistoryAdapter());
-        ServiceContainer.register(SERVICE_KEYS.providerFactory, new LangChainProviderAdapter());
-        ServiceContainer.register(SERVICE_KEYS.auditEmitter, new AuditRepositoryAdapter());
-        // ─────────────────────────────────────────────────────────────────────────
         const adapters = [];
         let httpServer;
         const taskWorker = new TaskWorker();

package/dist/http/routers/display.js

@@ -20,13 +20,18 @@ export function createDisplayRouter() {
         const onMessage = (payload) => {
             res.write(`data: ${JSON.stringify({ type: 'message', ...payload })}\n\n`);
         };
+        const onMessageSent = (payload) => {
+            res.write(`data: ${JSON.stringify({ type: 'message_sent', ...payload })}\n\n`);
+        };
         display.on('activity_start', onActivityStart);
         display.on('activity_end', onActivityEnd);
         display.on('message', onMessage);
+        display.on('message_sent', onMessageSent);
         req.on('close', () => {
             display.off('activity_start', onActivityStart);
             display.off('activity_end', onActivityEnd);
             display.off('message', onMessage);
+            display.off('message_sent', onMessageSent);
         });
     });
     return router;

package/dist/http/webhooks-router.js

@@ -12,6 +12,7 @@ const CreateWebhookSchema = z.object({
         .regex(/^[a-z0-9-_]+$/, 'Name must be a slug: lowercase letters, numbers, hyphens, underscores only'),
     prompt: z.string().min(1).max(10_000),
     notification_channels: z.array(z.enum(['ui', 'telegram', 'discord'])).min(1).default(['ui']),
+    requires_api_key: z.boolean().default(true),
 });
 const UpdateWebhookSchema = z.object({
     name: z
@@ -23,6 +24,7 @@ const UpdateWebhookSchema = z.object({
     prompt: z.string().min(1).max(10_000).optional(),
     enabled: z.boolean().optional(),
     notification_channels: z.array(z.enum(['ui', 'telegram', 'discord'])).min(1).optional(),
+    requires_api_key: z.boolean().optional(),
 });
 const MarkReadSchema = z.object({
     ids: z.array(z.string().uuid()).min(1),
@@ -39,14 +41,18 @@ export function createWebhooksRouter() {
     router.post('/trigger/:webhook_name', async (req, res) => {
         const { webhook_name } = req.params;
         const apiKey = req.headers['x-api-key'];
-        if (!apiKey || typeof apiKey !== 'string') {
-            return res.status(401).json({ error: 'Missing x-api-key header' });
-        }
-        const webhook = repo.getAndValidateWebhook(webhook_name, apiKey);
-        if (!webhook) {
-            // Intentionally ambiguous — don't reveal whether the name exists or is disabled
+        // 1. First lookup by name to check if it requires an API key
+        const webhook = repo.getWebhookByName(webhook_name);
+        if (!webhook || !webhook.enabled) {
+            // Intentionally ambiguous
             return res.status(401).json({ error: 'Invalid webhook name or api key' });
         }
+        // 2. Validate API key if required
+        if (webhook.requires_api_key) {
+            if (!apiKey || typeof apiKey !== 'string' || apiKey !== webhook.api_key) {
+                return res.status(401).json({ error: 'Invalid webhook name or api key' });
+            }
+        }
         const payload = req.body ?? {};
         // Create pending notification immediately
         const notification = repo.createNotification({

package/dist/runtime/audit/repository.js

@@ -46,19 +46,87 @@ export class AuditRepository {
     `);
     }
     insert(event) {
+        const createdAt = Date.now();
+        const eventId = randomUUID();
         try {
             this.db.prepare(`
         INSERT INTO audit_events
           (id, session_id, task_id, event_type, agent, tool_name, provider, model,
            input_tokens, output_tokens, duration_ms, status, metadata, created_at)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(randomUUID(), event.session_id, event.task_id ?? null, event.event_type, event.agent ?? null, event.tool_name ?? null, event.provider ?? null, event.model ?? null, event.input_tokens ?? null, event.output_tokens ?? null, event.duration_ms ?? null, event.status ?? null, event.metadata ? JSON.stringify(event.metadata) : null, Date.now());
+      `).run(eventId, event.session_id, event.task_id ?? null, event.event_type, event.agent ?? null, event.tool_name ?? null, event.provider ?? null, event.model ?? null, event.input_tokens ?? null, event.output_tokens ?? null, event.duration_ms ?? null, event.status ?? null, event.metadata ? JSON.stringify(event.metadata) : null, createdAt);
+            // Emit activity event for visualization when agent is working
+            this.emitActivityEvent(event, createdAt);
         }
         catch (err) {
             // Non-critical — never let audit recording break the main flow
             DisplayManager.getInstance().log(`AuditRepository.insert failed: ${err?.message ?? String(err)}`, { source: 'Audit', level: 'error' });
         }
     }
+    /**
+     * Emit activity events to DisplayManager for real-time visualization.
+     * This allows the frontend to show which agent is actively working.
+     */
+    emitActivityEvent(event, timestamp) {
+        const display = DisplayManager.getInstance();
+        const agent = event.agent;
+        // Only emit for agent-specific events (not system events like task_created/completed)
+        const agentEventTypes = ['llm_call', 'tool_call', 'mcp_tool', 'telephonist', 'skill_loaded', 'chronos_job', 'memory_recovery', 'memory_persist'];
+        if (!agent || !agentEventTypes.includes(event.event_type)) {
+            return;
+        }
+        // Build descriptive message based on event type
+        let message;
+        switch (event.event_type) {
+            case 'llm_call':
+                message = `LLM call (${event.model || event.provider || 'unknown'})`;
+                break;
+            case 'tool_call':
+                message = `Executing tool: ${event.tool_name || 'unknown'}`;
+                break;
+            case 'mcp_tool':
+                message = `MCP tool: ${event.tool_name || 'unknown'}`;
+                break;
+            case 'telephonist':
+                const op = event.metadata;
+                const operation = op?.operation;
+                message = operation === 'tts' ? 'Synthesizing TTS...' : 'Transcribing audio...';
+                break;
+            case 'skill_loaded':
+                message = `Loading skill: ${event.tool_name || 'unknown'}`;
+                break;
+            case 'chronos_job':
+                message = `Running scheduled job: ${event.tool_name || 'unknown'}`;
+                break;
+            case 'memory_recovery':
+                message = 'Recovering memories...';
+                break;
+            case 'memory_persist':
+                message = 'Persisting memories...';
+                break;
+            default:
+                message = `Working (${event.event_type})`;
+        }
+        // Emit activity_start with duration hint
+        // Frontend will use duration_ms to determine how long to keep agent active
+        display.emit('activity_start', {
+            agent: agent.toLowerCase(),
+            message,
+            timestamp,
+            duration_ms: event.duration_ms || 0,
+            event_type: event.event_type,
+        });
+        // Emit activity_end after duration (if duration_ms is provided)
+        if (event.duration_ms && event.duration_ms > 0) {
+            setTimeout(() => {
+                display.emit('activity_end', {
+                    agent: agent.toLowerCase(),
+                    timestamp: Date.now(),
+                    duration_ms: event.duration_ms,
+                });
+            }, Math.min(event.duration_ms, 30000)); // Cap at 30s to avoid long-running timeouts
+        }
+    }
     countBySession(sessionId) {
         const row = this.db.prepare(`SELECT COUNT(*) as n FROM audit_events WHERE session_id = ?`).get(sessionId);
         return row?.n ?? 0;

package/dist/runtime/chronos/worker.js

@@ -74,6 +74,7 @@ export class ChronosWorker {
     async executeJob(job) {
         const display = DisplayManager.getInstance();
         const execId = randomUUID();
+        display.startActivity('chronos', 'Running scheduled job...');
         display.log(`Job ${job.id} triggered — "${job.prompt.slice(0, 60)}"`, { source: 'Chronos' });
         // Resolve session: prefer the session where the job was originally created,
         // fall back to Oracle's current session, then to most recent active session.
@@ -150,6 +151,7 @@ export class ChronosWorker {
         }
         finally {
             ChronosWorker.isExecuting = false;
+            display.endActivity('chronos', true);
             if (job.schedule_type === 'once') {
                 this.repo.disableJob(job.id);
                 display.log(`Job ${job.id} auto-disabled (once-type)`, { source: 'Chronos' });

package/dist/runtime/display.js

@@ -70,6 +70,38 @@ export class DisplayManager extends EventEmitter {
             this.spinner.stop();
         }
     }
+    /**
+     * Start an activity for an agent - emits activity_start event for visualization.
+     * Use this when an agent begins a task (e.g., before calling an API).
+     */
+    startActivity(agent, message) {
+        this.emit('activity_start', {
+            agent: agent.toLowerCase(),
+            message,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * End an activity for an agent - emits activity_end event for visualization.
+     * Use this when an agent finishes a task (e.g., after receiving API response).
+     */
+    endActivity(agent, success) {
+        this.emit('activity_end', {
+            agent: agent.toLowerCase(),
+            timestamp: Date.now(),
+            success,
+        });
+    }
+    /**
+     * Emit a message sent event - for visualizing outgoing messages (e.g., rocket launching).
+     * This is a transient event that appears briefly in the visualizer.
+     */
+    emitMessageSent(agent = 'oracle') {
+        this.emit('message_sent', {
+            agent: agent.toLowerCase(),
+            timestamp: Date.now(),
+        });
+    }
     log(message, options) {
         const wasSpinning = this.spinner.isSpinning;
         const previousText = this.spinner.text;

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

@@ -25,6 +25,7 @@ export class SatiService {
         this.repository.initialize();
     }
     async recover(currentMessage, recentMessages) {
+        display.startActivity('sati', 'Recovering memories...');
         const satiConfig = ConfigManager.getInstance().getSatiConfig();
         const memoryLimit = satiConfig.memory_limit || 10;
         const enabled_vector_search = satiConfig.enabled_archived_sessions ?? true;
@@ -43,6 +44,7 @@ export class SatiService {
             console.warn('[Sati] Failed to generate embedding:', err);
         }
         const memories = this.repository.search(currentMessage, memoryLimit, queryEmbedding);
+        display.endActivity('sati', true);
         return {
             relevant_memories: memories.map(m => ({
                 summary: m.summary,
@@ -52,6 +54,7 @@ export class SatiService {
         };
     }
     async evaluateAndPersist(conversation, userSessionId) {
+        display.startActivity('sati', 'Evaluating and persisting memories...');
         try {
             const satiConfig = ConfigManager.getInstance().getSatiConfig();
             if (!satiConfig)
@@ -239,7 +242,9 @@ export class SatiService {
         }
         catch (error) {
             console.error('[SatiService] Evaluation failed:', error);
+            display.endActivity('sati', false);
         }
+        display.endActivity('sati', true);
     }
     generateHash(content) {
         return createHash('sha256').update(content.trim().toLowerCase()).digest('hex');

package/dist/runtime/oracle.js

@@ -519,6 +519,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
             let contextDelegationAcks = [];
             let syncDelegationCount = 0;
             const oracleStartMs = Date.now();
+            const display = DisplayManager.getInstance();
+            display.startActivity('oracle', `LLM call (${this.config.llm.model})`);
             const response = await TaskRequestContext.run(invokeContext, async () => {
                 const agentResponse = await this.provider.invoke({ messages }, { recursionLimit: 100 });
                 contextDelegationAcks = TaskRequestContext.getDelegationAcks();
@@ -526,6 +528,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
                 return agentResponse;
             });
             const oracleDurationMs = Date.now() - oracleStartMs;
+            display.endActivity('oracle', true);
             // Emit llm_call audit event for Oracle's own invocation
             try {
                 const lastMsg = response.messages[response.messages.length - 1];
@@ -643,6 +646,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
                     // Persist user message + all generated messages in a single transaction
                     await callHistory.addMessages([userMessage, ...newGeneratedMessages]);
                 }
+                // Emit message sent event for visualization (rocket animation)
+                this.display.emitMessageSent('oracle');
             }
             this.display.log('Response generated.', { source: 'Oracle' });
             // Sati Middleware: skip memory evaluation for delegation-only acknowledgements.

package/dist/runtime/providers/factory.js

@@ -14,23 +14,35 @@ export class ProviderFactory {
         return createMiddleware({
             name: "ToolMonitoringMiddleware",
             wrapToolCall: (request, handler) => {
-                display.log(`Executing tool: ${request.toolCall.name}`, { level: "warning", source: 'ConstructLoad' });
+                const toolName = request.toolCall.name;
+                // Determine which agent is running this tool based on context
+                // This is a heuristic - the actual agent should be passed in context
+                let agent = 'neo'; // Default to neo for MCP tools
+                const ctx = TaskRequestContext.get();
+                if (ctx?.session_id) {
+                    // Try to determine agent from context - this is a simplified approach
+                    // In practice, we'd need to pass the agent through the context
+                }
+                display.startActivity(agent, `Executing tool: ${toolName}`);
+                display.log(`Executing tool: ${toolName}`, { level: "warning", source: 'ConstructLoad' });
                 display.log(`Arguments: ${JSON.stringify(request.toolCall.args)}`, { level: "info", source: 'ConstructLoad' });
                 // Verbose mode: notify originating channel about which tool is running
                 const verboseEnabled = ConfigManager.getInstance().get().verbose_mode !== false;
                 if (verboseEnabled) {
                     const ctx = TaskRequestContext.get();
                     if (ctx?.origin_channel && ctx.origin_user_id && !SILENT_CHANNELS.has(ctx.origin_channel)) {
-                        ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, `🔧 executing: ${request.toolCall.name}`)
+                        ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, `🔧 executing: ${toolName}`)
                             .catch(() => { });
                     }
                 }
                 try {
                     const result = handler(request);
+                    display.endActivity(agent, true);
                     display.log(`Tool completed successfully. Result: ${JSON.stringify(result)}`, { level: "info", source: 'ConstructLoad' });
                     return result;
                 }
                 catch (e) {
+                    display.endActivity(agent, false);
                     display.log(`Tool failed: ${e}`, { level: "error", source: 'ConstructLoad' });
                     throw e;
                 }

package/dist/runtime/smiths/delegator.js

@@ -133,6 +133,7 @@ export class SmithDelegator {
             level: 'info',
             meta: { smith: smithName },
         });
+        this.display.startActivity('smith', `Delegating to Smith '${smithName}'...`);
         try {
             // Build proxy tools for this Smith's capabilities
             const proxyTools = this.buildProxyTools(smithName);
@@ -193,6 +194,7 @@ Respond in the same language as the task.`);
                 source: 'SmithDelegator',
                 level: 'info',
             });
+            this.display.endActivity('smith', true);
             return {
                 output: content,
                 usage: {
@@ -210,6 +212,7 @@ Respond in the same language as the task.`);
                 source: 'SmithDelegator',
                 level: 'error',
             });
+            this.display.endActivity('smith', false);
             return { output: `❌ Smith '${smithName}' delegation failed: ${err.message}` };
         }
     }

package/dist/runtime/subagents/devkit-instrument.js

@@ -1,4 +1,6 @@
 import { AuditRepository } from '../audit/repository.js';
+import { DisplayManager } from '../display.js';
+const display = DisplayManager.getInstance();
 /**
  * Wraps a StructuredTool to record audit events on each invocation.
  * The `getSessionId` getter is called at invocation time so it reflects
@@ -10,6 +12,7 @@ function instrumentTool(tool, getSessionId, getAgent) {
         const startMs = Date.now();
         const sessionId = getSessionId() ?? 'unknown';
         const agent = getAgent();
+        display.startActivity(agent, `Executing tool: ${tool.name}`);
         try {
             const result = await original(input, runManager);
             const durationMs = Date.now() - startMs;
@@ -21,9 +24,11 @@ function instrumentTool(tool, getSessionId, getAgent) {
                 duration_ms: durationMs,
                 status: 'success',
             });
+            display.endActivity(agent, true);
             return result;
         }
         catch (err) {
+            display.endActivity(agent, false);
             const durationMs = Date.now() - startMs;
             AuditRepository.getInstance().insert({
                 session_id: sessionId,