morpheus-cli 0.9.20 → 0.9.23

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/http/api.js

@@ -23,6 +23,7 @@ import { createSmithsRouter } from './routers/smiths.js';
 import { createDangerRouter } from './routers/danger.js';
 import { createLinkRouter } from './routers/link.js';
 import { createAgentsRouter } from './routers/agents.js';
+import { createDisplayRouter } from './routers/display.js';
 import { getActiveEnvOverrides } from '../config/precedence.js';
 import { hotReloadConfig, getRestartRequiredChanges } from '../runtime/hot-reload.js';
 import { AuditRepository } from '../runtime/audit/repository.js';
@@ -58,6 +59,8 @@ export function createApiRouter(oracle, chronosWorker) {
     router.use('/link', createLinkRouter());
     // Mount Agents metadata router
     router.use('/agents', createAgentsRouter());
+    // Mount Display Stream router
+    router.use('/display', createDisplayRouter());
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {

package/dist/http/middleware/auth.js

@@ -12,7 +12,8 @@ export const authMiddleware = (req, res, next) => {
         const display = DisplayManager.getInstance();
         // display.log('Using default password for dashboard access. For security, set THE_ARCHITECT_PASS environment variable.', { source: 'http', level: 'warning' });
     }
-    const providedPass = req.headers[AUTH_HEADER];
+    // Fallback to query param 'token' for EventSource and WebSockets which can't easily set headers
+    const providedPass = req.headers[AUTH_HEADER] || req.query.token;
     if (providedPass === architectPass) {
         return next();
     }

package/dist/http/routers/display.js

@@ -0,0 +1,38 @@
+import { Router } from 'express';
+import { DisplayManager } from '../../runtime/display.js';
+export function createDisplayRouter() {
+    const router = Router();
+    const display = DisplayManager.getInstance();
+    router.get('/stream', (req, res) => {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        // Flush headers to establish SSE instantly
+        res.flushHeaders?.();
+        // Send initial ping to confirm connection
+        res.write(`data: ${JSON.stringify({ type: 'connected', timestamp: Date.now() })}\n\n`);
+        const onActivityStart = (payload) => {
+            res.write(`data: ${JSON.stringify({ type: 'activity_start', ...payload })}\n\n`);
+        };
+        const onActivityEnd = (payload) => {
+            res.write(`data: ${JSON.stringify({ type: 'activity_end', ...payload })}\n\n`);
+        };
+        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/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

@@ -2,12 +2,14 @@ import ora from 'ora';
 import chalk from 'chalk';
 import winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
+import { EventEmitter } from 'events';
 import { LOGS_DIR } from '../config/paths.js';
-export class DisplayManager {
+export class DisplayManager extends EventEmitter {
     static instance;
     spinner;
     logger;
     constructor() {
+        super();
         this.spinner = ora();
     }
     static getInstance() {
@@ -38,7 +40,9 @@ export class DisplayManager {
             ],
         });
     }
-    startSpinner(text) {
+    startSpinner(text, source) {
+        const defaultAgentKey = source ? source.toLowerCase() : 'oracle';
+        this.emit('activity_start', { agent: defaultAgentKey, message: text || 'processing...', timestamp: Date.now() });
         if (this.spinner.isSpinning) {
             if (text) {
                 this.spinner.text = text;
@@ -53,6 +57,7 @@ export class DisplayManager {
         }
     }
     stopSpinner(success) {
+        this.emit('activity_end', { timestamp: Date.now(), success });
         if (!this.spinner.isSpinning)
             return;
         if (success === true) {
@@ -65,6 +70,38 @@ export class DisplayManager {
             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;
@@ -134,6 +171,16 @@ export class DisplayManager {
         // But existing log() Implementation didn't handle 'debug' specifically before I added it to type.
         // I'll leave console behavior as is (prints everything).
         console.log(`${prefix}${formattedMessage}`);
+        // Emit purely for visualization (ignoring debug if needed to keep stream light)
+        if (options?.level !== 'debug') {
+            this.emit('message', {
+                message,
+                source: options?.source || 'system',
+                level: options?.level || 'info',
+                timestamp: Date.now(),
+                meta: options?.meta
+            });
+        }
         if (this.logger) {
             try {
                 const level = this.mapLevel(options?.level);

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,