morpheus-cli 0.4.2 → 0.4.4

package/dist/channels/telegram.js

@@ -522,44 +522,83 @@ How can I assist you today?`;
         }
     }
     async handleDoctorCommand(ctx, user) {
-        // Implementação simplificada do diagnóstico
         const config = this.config.get();
         let response = '*Morpheus Doctor*\n\n';
         // Verificar versão do Node.js
         const nodeVersion = process.version;
         const majorVersion = parseInt(nodeVersion.replace('v', '').split('.')[0], 10);
         if (majorVersion >= 18) {
-            response += '✅ Node.js Version: ' + nodeVersion + ' (Satisfied)\n';
+            response += '✅ Node.js: ' + nodeVersion + '\n';
         }
         else {
-            response += '❌ Node.js Version: ' + nodeVersion + ' (Required: >=18)\n';
+            response += '❌ Node.js: ' + nodeVersion + ' (Required: >=18)\n';
         }
-        // Verificar configuração
         if (config) {
             response += '✅ Configuration: Valid\n';
-            // Verificar se há chave de API disponível para o provedor ativo
+            // Helper para verificar API key de um provider
+            const hasApiKey = (provider, apiKey) => {
+                if (apiKey)
+                    return true;
+                if (provider === 'openai')
+                    return !!process.env.OPENAI_API_KEY;
+                if (provider === 'anthropic')
+                    return !!process.env.ANTHROPIC_API_KEY;
+                if (provider === 'gemini' || provider === 'google')
+                    return !!process.env.GOOGLE_API_KEY;
+                if (provider === 'openrouter')
+                    return !!process.env.OPENROUTER_API_KEY;
+                return false; // ollama and others don't need keys
+            };
+            // Oracle (LLM)
             const llmProvider = config.llm?.provider;
             if (llmProvider && llmProvider !== 'ollama') {
-                const hasLlmApiKey = config.llm?.api_key ||
-                    (llmProvider === 'openai' && process.env.OPENAI_API_KEY) ||
-                    (llmProvider === 'anthropic' && process.env.ANTHROPIC_API_KEY) ||
-                    (llmProvider === 'gemini' && process.env.GOOGLE_API_KEY) ||
-                    (llmProvider === 'openrouter' && process.env.OPENROUTER_API_KEY);
-                if (hasLlmApiKey) {
-                    response += `✅ LLM API key available for ${llmProvider}\n`;
+                if (hasApiKey(llmProvider, config.llm?.api_key)) {
+                    response += `✅ Oracle API key (${llmProvider})\n`;
                 }
                 else {
-                    response += `❌ LLM API key missing for ${llmProvider}. Either set in config or define environment variable.\n`;
+                    response += `❌ Oracle API key missing (${llmProvider})\n`;
                 }
             }
-            // Verificar token do Telegram se ativado
+            // Sati
+            const sati = config.sati;
+            const satiProvider = sati?.provider || llmProvider;
+            if (satiProvider && satiProvider !== 'ollama') {
+                if (hasApiKey(satiProvider, sati?.api_key ?? config.llm?.api_key)) {
+                    response += `✅ Sati API key (${satiProvider})\n`;
+                }
+                else {
+                    response += `❌ Sati API key missing (${satiProvider})\n`;
+                }
+            }
+            // Apoc
+            const apoc = config.apoc;
+            const apocProvider = apoc?.provider || llmProvider;
+            if (apocProvider && apocProvider !== 'ollama') {
+                if (hasApiKey(apocProvider, apoc?.api_key ?? config.llm?.api_key)) {
+                    response += `✅ Apoc API key (${apocProvider})\n`;
+                }
+                else {
+                    response += `❌ Apoc API key missing (${apocProvider})\n`;
+                }
+            }
+            // Telegram token
             if (config.channels?.telegram?.enabled) {
                 const hasTelegramToken = config.channels.telegram?.token || process.env.TELEGRAM_BOT_TOKEN;
                 if (hasTelegramToken) {
-                    response += '✅ Telegram bot token available\n';
+                    response += '✅ Telegram token\n';
                 }
                 else {
-                    response += '❌ Telegram bot token missing. Either set in config or define TELEGRAM_BOT_TOKEN environment variable.\n';
+                    response += '❌ Telegram token missing\n';
+                }
+            }
+            // Audio API key
+            if (config.audio?.enabled) {
+                const audioKey = config.audio?.apiKey || process.env.GOOGLE_API_KEY;
+                if (audioKey) {
+                    response += '✅ Audio API key\n';
+                }
+                else {
+                    response += '❌ Audio API key missing\n';
                 }
             }
         }
@@ -570,29 +609,46 @@ How can I assist you today?`;
     }
     async handleStatsCommand(ctx, user) {
         try {
-            // Criar instância temporária do histórico para obter estatísticas
             const history = new SQLiteChatMessageHistory({
                 sessionId: "default",
-                databasePath: undefined, // Usará o caminho padrão
-                limit: 100, // Limite arbitrário para esta operação
+                databasePath: undefined,
+                limit: 100,
             });
             const stats = await history.getGlobalUsageStats();
             const groupedStats = await history.getUsageStatsByProviderAndModel();
+            // Totals from global stats
+            const totalTokens = stats.totalInputTokens + stats.totalOutputTokens;
+            // Aggregate audio seconds and cost from grouped stats
+            const totalAudioSeconds = groupedStats.reduce((sum, s) => sum + (s.totalAudioSeconds || 0), 0);
+            const totalCost = stats.totalEstimatedCostUsd;
             let response = '*Token Usage Statistics*\n\n';
-            response += `Total Input Tokens: ${stats.totalInputTokens}\n`;
-            response += `Total Output Tokens: ${stats.totalOutputTokens}\n`;
-            response += `Total Tokens: ${stats.totalInputTokens + stats.totalOutputTokens}\n\n`;
+            response += `Input Tokens: ${stats.totalInputTokens.toLocaleString()}\n`;
+            response += `Output Tokens: ${stats.totalOutputTokens.toLocaleString()}\n`;
+            response += `Total Tokens: ${totalTokens.toLocaleString()}\n`;
+            if (totalAudioSeconds > 0) {
+                response += `Audio Processed: ${totalAudioSeconds.toFixed(1)}s\n`;
+            }
+            if (totalCost != null) {
+                response += `Estimated Cost: $${totalCost.toFixed(4)}\n`;
+            }
+            response += '\n';
             if (groupedStats.length > 0) {
-                response += '*Breakdown by Provider and Model:*\n';
+                response += '*By Provider/Model:*\n';
                 for (const stat of groupedStats) {
-                    response += `- ${stat.provider}/${stat.model}:\n ${stat.totalTokens} tokens\n(${stat.messageCount} messages)\n\n`;
+                    response += `\n*${stat.provider}/${stat.model}*\n`;
+                    response += `  Tokens: ${stat.totalTokens.toLocaleString()} (${stat.messageCount} msgs)\n`;
+                    if (stat.totalAudioSeconds > 0) {
+                        response += `  Audio: ${stat.totalAudioSeconds.toFixed(1)}s\n`;
+                    }
+                    if (stat.estimatedCostUsd != null) {
+                        response += `  Cost: $${stat.estimatedCostUsd.toFixed(4)}\n`;
+                    }
                 }
             }
             else {
                 response += 'No detailed usage statistics available.';
             }
             await ctx.reply(response, { parse_mode: 'Markdown' });
-            // Fechar conexão com o banco de dados
             history.close();
         }
         catch (error) {
@@ -632,11 +688,39 @@ How can I assist you today?`;
         response += `*Agent:*\n`;
         response += `- Name: ${config.agent.name}\n`;
         response += `- Personality: ${config.agent.personality}\n\n`;
-        response += `*LLM:*\n`;
+        response += `*Oracle (LLM):*\n`;
         response += `- Provider: ${config.llm.provider}\n`;
         response += `- Model: ${config.llm.model}\n`;
         response += `- Temperature: ${config.llm.temperature}\n`;
         response += `- Context Window: ${config.llm.context_window || 100}\n\n`;
+        // Sati config (falls back to llm if not set)
+        const sati = config.sati;
+        response += `*Sati (Memory):*\n`;
+        if (sati?.provider) {
+            response += `- Provider: ${sati.provider}\n`;
+            response += `- Model: ${sati.model || config.llm.model}\n`;
+            response += `- Temperature: ${sati.temperature ?? config.llm.temperature}\n`;
+            response += `- Memory Limit: ${sati.memory_limit ?? 1000}\n`;
+        }
+        else {
+            response += `- Inherits Oracle config\n`;
+        }
+        response += '\n';
+        // Apoc config (falls back to llm if not set)
+        const apoc = config.apoc;
+        response += `*Apoc (DevTools):*\n`;
+        if (apoc?.provider) {
+            response += `- Provider: ${apoc.provider}\n`;
+            response += `- Model: ${apoc.model || config.llm.model}\n`;
+            response += `- Temperature: ${apoc.temperature ?? 0.2}\n`;
+            if (apoc.working_dir)
+                response += `- Working Dir: ${apoc.working_dir}\n`;
+            response += `- Timeout: ${apoc.timeout_ms ?? 30000}ms\n`;
+        }
+        else {
+            response += `- Inherits Oracle config\n`;
+        }
+        response += '\n';
         response += `*Channels:*\n`;
         response += `- Telegram Enabled: ${config.channels.telegram.enabled}\n`;
         response += `- Discord Enabled: ${config.channels.discord.enabled}\n\n`;

package/dist/cli/commands/start.js

@@ -4,7 +4,7 @@ import fs from 'fs-extra';
 import { confirm } from '@inquirer/prompts';
 import { scaffold } from '../../runtime/scaffold.js';
 import { DisplayManager } from '../../runtime/display.js';
-import { writePid, readPid, isProcessRunning, clearPid, checkStalePid, killProcess } from '../../runtime/lifecycle.js';
+import { writePid, readPid, isProcessRunning, clearPid, checkStalePid, killProcess, waitForProcessDeath } from '../../runtime/lifecycle.js';
 import { ConfigManager } from '../../config/manager.js';
 import { renderBanner } from '../utils/render.js';
 import { TelegramAdapter } from '../../channels/telegram.js';
@@ -28,7 +28,8 @@ export const startCommand = new Command('start')
         // Cleanup stale PID first
         await checkStalePid();
         const existingPid = await readPid();
-        if (existingPid !== null && isProcessRunning(existingPid)) {
+        // Guard: skip if the stored PID is our own (container restart PID reuse scenario)
+        if (existingPid !== null && existingPid !== process.pid && isProcessRunning(existingPid)) {
             display.log(chalk.yellow(`Morpheus is already running (PID: ${existingPid})`));
             let shouldKill = options.yes;
             if (!shouldKill) {
@@ -48,10 +49,13 @@ export const startCommand = new Command('start')
                 display.log(chalk.cyan(`Stopping existing process (PID: ${existingPid})...`));
                 const killed = killProcess(existingPid);
                 if (killed) {
-                    display.log(chalk.green('✓ Process stopped successfully'));
+                    display.log(chalk.green('Terminated'));
                     await clearPid();
-                    // Give a moment for the process to fully terminate
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    // Wait up to 5 s for the process to actually die before continuing
+                    const died = await waitForProcessDeath(existingPid, 5000);
+                    if (!died) {
+                        display.log(chalk.yellow('Warning: process may still be running. Proceeding anyway.'));
+                    }
                 }
                 else {
                     display.log(chalk.red('Failed to stop the process'));

package/dist/runtime/lifecycle.js

@@ -31,15 +31,37 @@ export function isProcessRunning(pid) {
         return e.code === 'EPERM'; // If EPERM, it exists but we lack permission (still running)
     }
 }
+/**
+ * Waits until the given PID is no longer running, or until timeout is reached.
+ * Returns true if the process died, false if timeout was reached.
+ */
+export async function waitForProcessDeath(pid, timeoutMs = 5000, intervalMs = 200) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid))
+            return true;
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    return !isProcessRunning(pid);
+}
 export async function checkStalePid() {
     const pid = await readPid();
     if (pid !== null) {
+        // Never treat our own PID as stale — this avoids self-kill loops in containers
+        // where a restarted process may inherit the same PID that was previously written.
+        if (pid === process.pid) {
+            await clearPid();
+            return;
+        }
         if (!isProcessRunning(pid)) {
             await clearPid();
         }
     }
 }
 export function killProcess(pid) {
+    // Safety guard: never kill ourselves
+    if (pid === process.pid)
+        return false;
     try {
         process.kill(pid, 'SIGTERM');
         return true;

package/dist/runtime/tools/analytics-tools.js

@@ -1,22 +1,22 @@
 import { tool } from "langchain";
 import * as z from "zod";
-import path from "path";
 import Database from "better-sqlite3";
 import { homedir } from "os";
-// Tool for querying message counts from the database
+import path from "path";
 const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+// Tool for querying message counts from the database
 export const MessageCountTool = tool(async ({ timeRange }) => {
     try {
-        // Connect to database
         const db = new Database(dbPath);
+        // The messages table uses `created_at` (Unix ms integer), not `timestamp`
         let query = "SELECT COUNT(*) as count FROM messages";
         const params = [];
         if (timeRange) {
-            query += " WHERE timestamp BETWEEN ? AND ?";
-            params.push(timeRange.start);
-            params.push(timeRange.end);
+            query += " WHERE created_at BETWEEN ? AND ?";
+            params.push(new Date(timeRange.start).getTime());
+            params.push(new Date(timeRange.end).getTime());
         }
-        const result = db.prepare(query).get(params);
+        const result = db.prepare(query).get(...params);
         db.close();
         return JSON.stringify(result.count);
     }
@@ -26,11 +26,11 @@ export const MessageCountTool = tool(async ({ timeRange }) => {
     }
 }, {
     name: "message_count",
-    description: "Returns count of stored messages. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    description: "Returns count of stored messages. Accepts an optional 'timeRange' parameter with ISO date strings (start/end) for filtering.",
     schema: z.object({
         timeRange: z.object({
-            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
-            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            start: z.string().describe("ISO date string, e.g. 2026-01-01T00:00:00Z"),
+            end: z.string().describe("ISO date string, e.g. 2026-12-31T23:59:59Z"),
         }).optional(),
     }),
 });
@@ -39,20 +39,44 @@ export const ProviderModelUsageTool = tool(async () => {
     try {
         const db = new Database(dbPath);
         const query = `
-        SELECT 
-          provider,
-          COALESCE(model, 'unknown') as model,
-          SUM(input_tokens) as totalInputTokens,
-          SUM(output_tokens) as totalOutputTokens,
-          SUM(total_tokens) as totalTokens,
-          COUNT(*) as messageCount
-        FROM messages
-        WHERE provider IS NOT NULL
-        GROUP BY provider, COALESCE(model, 'unknown')
-        ORDER BY provider, model
+        SELECT
+          m.provider,
+          COALESCE(m.model, 'unknown') as model,
+          SUM(m.input_tokens) as totalInputTokens,
+          SUM(m.output_tokens) as totalOutputTokens,
+          SUM(m.total_tokens) as totalTokens,
+          COUNT(*) as messageCount,
+          COALESCE(SUM(m.audio_duration_seconds), 0) as totalAudioSeconds,
+          p.input_price_per_1m,
+          p.output_price_per_1m
+        FROM messages m
+        LEFT JOIN model_pricing p ON p.provider = m.provider AND p.model = COALESCE(m.model, 'unknown')
+        WHERE m.provider IS NOT NULL
+        GROUP BY m.provider, COALESCE(m.model, 'unknown')
+        ORDER BY m.provider, m.model
       `;
-        const results = db.prepare(query).all();
+        const rows = db.prepare(query).all();
         db.close();
+        const results = rows.map(row => {
+            const inputTokens = row.totalInputTokens || 0;
+            const outputTokens = row.totalOutputTokens || 0;
+            let estimatedCostUsd = null;
+            if (row.input_price_per_1m != null && row.output_price_per_1m != null) {
+                estimatedCostUsd =
+                    (inputTokens / 1_000_000) * row.input_price_per_1m +
+                        (outputTokens / 1_000_000) * row.output_price_per_1m;
+            }
+            return {
+                provider: row.provider,
+                model: row.model,
+                totalInputTokens: inputTokens,
+                totalOutputTokens: outputTokens,
+                totalTokens: row.totalTokens || 0,
+                messageCount: row.messageCount || 0,
+                totalAudioSeconds: row.totalAudioSeconds || 0,
+                estimatedCostUsd,
+            };
+        });
         return JSON.stringify(results);
     }
     catch (error) {
@@ -61,31 +85,43 @@ export const ProviderModelUsageTool = tool(async () => {
     }
 }, {
     name: "provider_model_usage",
-    description: "Returns token usage statistics grouped by provider and model.",
+    description: "Returns token usage statistics grouped by provider and model, including audio duration and estimated cost in USD (when pricing is configured).",
     schema: z.object({}),
 });
-// Tool for querying token usage statistics from the database
+// Tool for querying global token usage statistics from the database
 export const TokenUsageTool = tool(async ({ timeRange }) => {
     try {
-        // Connect to database
         const db = new Database(dbPath);
-        let query = "SELECT SUM(input_tokens) as inputTokens, SUM(output_tokens) as outputTokens, SUM(input_tokens + output_tokens) as totalTokens FROM messages";
+        // The messages table uses `created_at` (Unix ms integer), not `timestamp`
+        let whereClause = "";
         const params = [];
         if (timeRange) {
-            query += " WHERE timestamp BETWEEN ? AND ?";
-            params.push(timeRange.start);
-            params.push(timeRange.end);
+            whereClause = " WHERE created_at BETWEEN ? AND ?";
+            params.push(new Date(timeRange.start).getTime());
+            params.push(new Date(timeRange.end).getTime());
         }
-        const result = db.prepare(query).get(params);
+        const row = db.prepare(`SELECT
+           SUM(input_tokens) as inputTokens,
+           SUM(output_tokens) as outputTokens,
+           SUM(total_tokens) as totalTokens,
+           COALESCE(SUM(audio_duration_seconds), 0) as totalAudioSeconds
+         FROM messages${whereClause}`).get(...params);
+        // Estimated cost via model_pricing join
+        const costRow = db.prepare(`SELECT
+           SUM((COALESCE(m.input_tokens, 0) / 1000000.0) * p.input_price_per_1m
+             + (COALESCE(m.output_tokens, 0) / 1000000.0) * p.output_price_per_1m) as totalCost
+         FROM messages m
+         INNER JOIN model_pricing p ON p.provider = m.provider AND p.model = COALESCE(m.model, 'unknown')
+         WHERE m.provider IS NOT NULL${whereClause ? whereClause.replace("WHERE", "AND") : ""}`).get(...params);
         db.close();
-        // Handle potential null values
-        const tokenStats = {
-            totalTokens: result.totalTokens || 0,
-            inputTokens: result.inputTokens || 0,
-            outputTokens: result.outputTokens || 0,
-            timestamp: new Date().toISOString()
-        };
-        return JSON.stringify(tokenStats);
+        return JSON.stringify({
+            inputTokens: row.inputTokens || 0,
+            outputTokens: row.outputTokens || 0,
+            totalTokens: row.totalTokens || 0,
+            totalAudioSeconds: row.totalAudioSeconds || 0,
+            estimatedCostUsd: costRow.totalCost ?? null,
+            timestamp: new Date().toISOString(),
+        });
     }
     catch (error) {
         console.error("Error in TokenUsageTool:", error);
@@ -93,11 +129,11 @@ export const TokenUsageTool = tool(async ({ timeRange }) => {
     }
 }, {
     name: "token_usage",
-    description: "Returns token usage statistics. Accepts an optional 'timeRange' parameter with start and end timestamps for filtering.",
+    description: "Returns global token usage statistics including input/output tokens, total tokens, audio duration in seconds, and estimated cost in USD (when pricing is configured). Accepts an optional 'timeRange' parameter with ISO date strings for filtering.",
     schema: z.object({
         timeRange: z.object({
-            start: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
-            end: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/, "ISO date string"),
+            start: z.string().describe("ISO date string, e.g. 2026-01-01T00:00:00Z"),
+            end: z.string().describe("ISO date string, e.g. 2026-12-31T23:59:59Z"),
         }).optional(),
     }),
 });

package/dist/runtime/tools/diagnostic-tools.js

@@ -9,30 +9,38 @@ export const DiagnosticTool = tool(async () => {
     try {
         const timestamp = new Date().toISOString();
         const components = {};
-        // Check configuration
+        const morpheusRoot = path.join(homedir(), ".morpheus");
+        // ── Configuration ──────────────────────────────────────────────
         try {
             const configManager = ConfigManager.getInstance();
             await configManager.load();
             const config = configManager.get();
-            // Basic validation - check if required fields exist
-            const requiredFields = ['llm', 'logging', 'ui'];
+            const requiredFields = ["llm", "logging", "ui"];
             const missingFields = requiredFields.filter(field => !(field in config));
             if (missingFields.length === 0) {
+                const sati = config.sati;
+                const apoc = config.apoc;
                 components.config = {
                     status: "healthy",
                     message: "Configuration is valid and complete",
                     details: {
-                        llmProvider: config.llm?.provider,
+                        oracleProvider: config.llm?.provider,
+                        oracleModel: config.llm?.model,
+                        satiProvider: sati?.provider ?? `${config.llm?.provider} (inherited)`,
+                        satiModel: sati?.model ?? `${config.llm?.model} (inherited)`,
+                        apocProvider: apoc?.provider ?? `${config.llm?.provider} (inherited)`,
+                        apocModel: apoc?.model ?? `${config.llm?.model} (inherited)`,
+                        apocWorkingDir: apoc?.working_dir ?? "not set",
                         uiEnabled: config.ui?.enabled,
-                        uiPort: config.ui?.port
-                    }
+                        uiPort: config.ui?.port,
+                    },
                 };
             }
             else {
                 components.config = {
                     status: "warning",
-                    message: `Missing required configuration fields: ${missingFields.join(', ')}`,
-                    details: { missingFields }
+                    message: `Missing required configuration fields: ${missingFields.join(", ")}`,
+                    details: { missingFields },
                 };
             }
         }
@@ -40,45 +48,62 @@ export const DiagnosticTool = tool(async () => {
             components.config = {
                 status: "error",
                 message: `Configuration error: ${error.message}`,
-                details: {}
+                details: {},
             };
         }
-        // Check storage/database
+        // ── Short-term memory DB ────────────────────────────────────────
         try {
-            // For now, we'll check if the data directory exists
-            const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+            const dbPath = path.join(morpheusRoot, "memory", "short-memory.db");
             await fsPromises.access(dbPath);
-            components.storage = {
+            const stat = await fsPromises.stat(dbPath);
+            components.shortMemoryDb = {
                 status: "healthy",
-                message: "Database file is accessible",
-                details: { path: dbPath }
+                message: "Short-memory database is accessible",
+                details: { path: dbPath, sizeBytes: stat.size },
             };
         }
         catch (error) {
-            components.storage = {
+            components.shortMemoryDb = {
                 status: "error",
-                message: `Storage error: ${error.message}`,
-                details: {}
+                message: `Short-memory DB not accessible: ${error.message}`,
+                details: {},
             };
         }
-        // Check network connectivity (basic check)
+        // ── Sati long-term memory DB ────────────────────────────────────
+        try {
+            const satiDbPath = path.join(morpheusRoot, "memory", "sati-memory.db");
+            await fsPromises.access(satiDbPath);
+            const stat = await fsPromises.stat(satiDbPath);
+            components.satiMemoryDb = {
+                status: "healthy",
+                message: "Sati memory database is accessible",
+                details: { path: satiDbPath, sizeBytes: stat.size },
+            };
+        }
+        catch {
+            // Sati DB may not exist yet if no memories have been stored — treat as warning
+            components.satiMemoryDb = {
+                status: "warning",
+                message: "Sati memory database does not exist yet (no memories stored yet)",
+                details: {},
+            };
+        }
+        // ── LLM provider configured ─────────────────────────────────────
         try {
-            // For now, we'll just check if we can reach the LLM provider configuration
             const configManager = ConfigManager.getInstance();
-            await configManager.load();
             const config = configManager.get();
-            if (config.llm && config.llm.provider) {
+            if (config.llm?.provider) {
                 components.network = {
                     status: "healthy",
-                    message: `LLM provider configured: ${config.llm.provider}`,
-                    details: { provider: config.llm.provider }
+                    message: `Oracle LLM provider configured: ${config.llm.provider}`,
+                    details: { provider: config.llm.provider, model: config.llm.model },
                 };
             }
             else {
                 components.network = {
                     status: "warning",
-                    message: "No LLM provider configured",
-                    details: {}
+                    message: "No Oracle LLM provider configured",
+                    details: {},
                 };
             }
         }
@@ -86,39 +111,43 @@ export const DiagnosticTool = tool(async () => {
             components.network = {
                 status: "error",
                 message: `Network check error: ${error.message}`,
-                details: {}
+                details: {},
             };
         }
-        // Check if the agent is running
+        // ── Agent process ───────────────────────────────────────────────
+        components.agent = {
+            status: "healthy",
+            message: "Agent is running (this tool is executing inside the agent process)",
+            details: { pid: process.pid, uptime: `${Math.floor(process.uptime())}s` },
+        };
+        // ── Logs directory ──────────────────────────────────────────────
         try {
-            // This is a basic check - in a real implementation, we might check if the agent process is running
-            components.agent = {
+            const logsDir = path.join(morpheusRoot, "logs");
+            await fsPromises.access(logsDir);
+            components.logs = {
                 status: "healthy",
-                message: "Agent is running",
-                details: { uptime: "N/A - runtime information not available in this context" }
+                message: "Logs directory is accessible",
+                details: { path: logsDir },
             };
         }
-        catch (error) {
-            components.agent = {
-                status: "error",
-                message: `Agent check error: ${error.message}`,
-                details: {}
+        catch {
+            components.logs = {
+                status: "warning",
+                message: "Logs directory not found (will be created on first log write)",
+                details: {},
             };
         }
-        return JSON.stringify({
-            timestamp,
-            components
-        });
+        return JSON.stringify({ timestamp, components });
     }
     catch (error) {
         console.error("Error in DiagnosticTool:", error);
         return JSON.stringify({
             timestamp: new Date().toISOString(),
-            error: "Failed to run diagnostics"
+            error: "Failed to run diagnostics",
         });
     }
 }, {
     name: "diagnostic_check",
-    description: "Performs system health diagnostics and returns a comprehensive report on system components.",
+    description: "Performs system health diagnostics and returns a comprehensive report covering configuration (Oracle/Sati/Apoc), short-memory DB, Sati long-term memory DB, LLM provider, agent process, and logs directory.",
     schema: z.object({}),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Morpheus is a local AI agent for developers, running as a CLI daemon that connects to LLMs, local tools, and MCPs, enabling interaction via Terminal, Telegram, and Discord. Inspired by the character Morpheus from *The Matrix*, the project acts as an intelligent orchestrator, bridging the gap between the developer and complex systems.",
   "bin": {
     "morpheus": "./bin/morpheus.js"