morpheus-cli 0.9.13 → 0.9.20

package/README.md

@@ -273,7 +273,7 @@ Task results are delivered proactively with metadata (task id, agent, status) an
 - `/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.
+**Voice messages:** Telegram voice messages are automatically transcribed (Gemini / Whisper / OpenRouter) and processed as text through the Oracle. If **TTS** is enabled (`audio.tts.enabled: true`), Oracle's response is synthesized back to audio and sent as a voice message. Falls back to text if synthesis fails.
 
 ## Discord Experience
 
@@ -302,7 +302,7 @@ Discord bot responds to **DMs only** from authorized user IDs (`allowedUsers`).
 | `/chronos_enable id:` | Enable a job |
 | `/chronos_delete id:` | Delete a job |
 
-**Voice messages:** Discord voice messages and audio file attachments are transcribed and processed identically to Telegram.
+**Voice messages:** Discord voice messages and audio file attachments are transcribed and processed identically to Telegram. TTS audio responses are also supported when enabled.
 
 **Setup:**
 1. Create an application at [discord.com/developers](https://discord.com/developers/applications).
@@ -330,14 +330,15 @@ The dashboard includes:
 - Agent settings (Oracle/Sati/Neo/Apoc/Trinity/Smiths)
 - MCP manager (add/edit/delete/toggle/reload)
 - Sati memories (search, bulk delete, pagination)
-- Usage stats and model pricing
+- Usage stats and model pricing (with optional currency conversion)
 - 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)
+- Audit dashboard (session audit, tool call tracking, cost breakdowns with currency conversion)
 - Webhooks and notification inbox
 - Logs viewer
 - Danger Zone (Settings → reset sessions, tasks, jobs, audit, or factory reset)
+- Display currency setting (Settings → Interface): converts USD costs to BRL, EUR, CAD, JPY, GBP, AUD, CHF, ARS, or any custom currency
 
 Chat-specific rendering:
 - AI messages rendered as markdown
@@ -422,6 +423,17 @@ audio:
   provider: google
   model: gemini-2.5-flash-lite
   maxDurationSeconds: 300
+  tts:
+    enabled: false           # set to true to respond with audio
+    provider: google         # openai | google
+    model: gemini-2.5-flash-preview-tts
+    voice: Kore              # voice name (provider-specific)
+    style_prompt: ""         # optional tone/style prefix (Gemini only)
+
+currency:                    # display currency for cost dashboards
+  code: USD                  # ISO 4217 code (e.g. BRL, EUR)
+  symbol: $                  # symbol shown in UI
+  rate: 1.0                  # conversion rate from USD
 
 logging:
   enabled: true
@@ -490,6 +502,15 @@ Generic Morpheus overrides (selected):
 | `MORPHEUS_AUDIO_ENABLED` | `audio.enabled` |
 | `MORPHEUS_AUDIO_API_KEY` | `audio.apiKey` |
 | `MORPHEUS_AUDIO_MAX_DURATION` | `audio.maxDurationSeconds` |
+| `MORPHEUS_AUDIO_TTS_ENABLED` | `audio.tts.enabled` |
+| `MORPHEUS_AUDIO_TTS_PROVIDER` | `audio.tts.provider` |
+| `MORPHEUS_AUDIO_TTS_MODEL` | `audio.tts.model` |
+| `MORPHEUS_AUDIO_TTS_VOICE` | `audio.tts.voice` |
+| `MORPHEUS_AUDIO_TTS_API_KEY` | `audio.tts.apiKey` |
+| `MORPHEUS_AUDIO_TTS_STYLE_PROMPT` | `audio.tts.style_prompt` |
+| `MORPHEUS_CURRENCY_CODE` | `currency.code` |
+| `MORPHEUS_CURRENCY_SYMBOL` | `currency.symbol` |
+| `MORPHEUS_CURRENCY_RATE` | `currency.rate` |
 | `MORPHEUS_TELEGRAM_ENABLED` | `channels.telegram.enabled` |
 | `MORPHEUS_TELEGRAM_TOKEN` | `channels.telegram.token` |
 | `MORPHEUS_TELEGRAM_ALLOWED_USERS` | `channels.telegram.allowedUsers` |
@@ -780,24 +801,34 @@ src/
     discord.ts           # Discord adapter (slash commands, voice, DM-only)
     registry.ts          # ChannelRegistry — central adapter router
   cli/         # start/stop/restart/status/doctor
-  config/      # config loading, precedence, schemas
+  config/
+    paths.ts             # Centralized PATHS constants (all DB/dir paths)
+    schemas.ts           # Zod validation schemas
+    manager.ts           # Config loading + env precedence
   devkit/      # Apoc tool factories
   http/        # API, auth, webhooks, server
   runtime/
-    apoc.ts
-    neo.ts
-    oracle.ts
-    trinity.ts
-    trinity-connector.ts  # PostgreSQL/MySQL/SQLite/MongoDB drivers
-    trinity-crypto.ts     # AES-256-GCM encryption for DB passwords
+    container.ts         # ServiceContainer — DI composition root
+    oracle.ts            # Orchestration brain
+    ports/               # Port interfaces (INotifier, ITaskEnqueuer, IChatHistory, ILLMProviderFactory, IAuditEmitter)
+    adapters/            # Concrete adapter implementations for ports
+    providers/
+      factory.ts         # ProviderFactory — strategy-based LLM creation
+      strategies.ts      # IProviderStrategy + per-provider implementations
+    subagents/
+      registry.ts        # SubagentRegistry — single source of truth
+      apoc.ts            # DevKit execution subagent
+      neo.ts             # MCP tool orchestration subagent
+      trinity/           # Database specialist subagent
+      link/              # Document RAG subagent
     chronos/
-      worker.ts           # polling timer and job execution
-      repository.ts       # SQLite-backed job and execution store
-      parser.ts           # natural-language schedule parser
+      worker.ts          # polling timer and job execution
+      repository.ts      # SQLite-backed job and execution store
+      parser.ts          # natural-language schedule parser
     smiths/
-      registry.ts         # SmithRegistry — manages all connections
-      connection.ts       # WebSocket client per Smith instance
-      delegator.ts        # LLM agent with proxy tools for remote execution
+      registry.ts        # SmithRegistry — manages all connections
+      connection.ts      # WebSocket client per Smith instance
+      delegator.ts       # LLM agent with proxy tools for remote execution
     memory/
     tasks/
     tools/

package/dist/channels/discord.js

@@ -1,4 +1,4 @@
-import { Client, GatewayIntentBits, Partials, Events, ChannelType, REST, Routes, SlashCommandBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, ComponentType, } from 'discord.js';
+import { Client, GatewayIntentBits, Partials, Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, ComponentType, } from 'discord.js';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
@@ -6,7 +6,8 @@ import os from 'os';
 import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
 import { DisplayManager } from '../runtime/display.js';
 import { ConfigManager } from '../config/manager.js';
-import { createTelephonist } from '../runtime/telephonist.js';
+import { createTelephonist, createTtsTelephonist } from '../runtime/telephonist.js';
+import { AuditRepository } from '../runtime/audit/repository.js';
 import { getUsableApiKey } from '../runtime/trinity-crypto.js';
 // ─── Slash Command Definitions ────────────────────────────────────────────────
 const SLASH_COMMANDS = [
@@ -117,6 +118,9 @@ export class DiscordAdapter {
     telephonist = null;
     telephonistProvider = null;
     telephonistModel = null;
+    ttsTelephonist = null;
+    ttsProvider = null;
+    ttsModel = null;
     RATE_LIMIT_MS = 3000;
     constructor(oracle) {
         this.oracle = oracle;
@@ -281,6 +285,13 @@ export class DiscordAdapter {
             this.telephonistProvider = config.audio.provider;
             this.telephonistModel = config.audio.model;
         }
+        // Lazy-create TTS telephonist
+        const ttsConfig = config.audio.tts;
+        if (ttsConfig?.enabled && (!this.ttsTelephonist || this.ttsProvider !== ttsConfig.provider || this.ttsModel !== ttsConfig.model)) {
+            this.ttsTelephonist = createTtsTelephonist(ttsConfig);
+            this.ttsProvider = ttsConfig.provider;
+            this.ttsModel = ttsConfig.model;
+        }
         // Voice messages expose duration (in seconds); regular attachments don't
         const duration = attachment.duration;
         if (duration && duration > config.audio.maxDurationSeconds) {
@@ -310,11 +321,87 @@ export class DiscordAdapter {
                 origin_user_id: userId,
             });
             if (response) {
-                const chunks = this.chunkText(response);
-                for (const chunk of chunks) {
-                    await channel.send(chunk);
+                if (ttsConfig?.enabled && this.ttsTelephonist?.synthesize) {
+                    // TTS path: synthesize and send as voice attachment
+                    let ttsFilePath = null;
+                    const ttsStart = Date.now();
+                    try {
+                        const ttsApiKey = getUsableApiKey(ttsConfig.apiKey) ||
+                            getUsableApiKey(config.audio.apiKey) ||
+                            (config.llm.provider === (ttsConfig.provider === 'google' ? 'gemini' : ttsConfig.provider)
+                                ? getUsableApiKey(config.llm.api_key) : undefined);
+                        const ttsResult = await this.ttsTelephonist.synthesize(response, ttsApiKey || '', ttsConfig.voice, ttsConfig.style_prompt);
+                        ttsFilePath = ttsResult.filePath;
+                        const ttsDurationMs = Date.now() - ttsStart;
+                        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' });
+                        // Audit TTS success
+                        try {
+                            const auditSessionId = await this.getSessionForUser(userId);
+                            AuditRepository.getInstance().insert({
+                                session_id: auditSessionId,
+                                event_type: 'telephonist',
+                                agent: 'telephonist',
+                                provider: ttsConfig.provider,
+                                model: ttsConfig.model,
+                                input_tokens: ttsResult.usage.input_tokens || null,
+                                output_tokens: ttsResult.usage.output_tokens || null,
+                                duration_ms: ttsDurationMs,
+                                status: 'success',
+                                metadata: {
+                                    operation: 'tts',
+                                    characters: response.length,
+                                    voice: ttsConfig.voice,
+                                    user: message.author.tag,
+                                },
+                            });
+                        }
+                        catch {
+                            // Audit failure never breaks the main flow
+                        }
+                    }
+                    catch (ttsError) {
+                        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
+                        try {
+                            const auditSessionId = await this.getSessionForUser(userId);
+                            AuditRepository.getInstance().insert({
+                                session_id: auditSessionId,
+                                event_type: 'telephonist',
+                                agent: 'telephonist',
+                                provider: ttsConfig.provider,
+                                model: ttsConfig.model,
+                                duration_ms: Date.now() - ttsStart,
+                                status: 'error',
+                                metadata: { operation: 'tts', error: ttsDetail, user: message.author.tag },
+                            });
+                        }
+                        catch {
+                            // Audit failure never breaks the main flow
+                        }
+                        // Fallback to text
+                        const chunks = this.chunkText(response);
+                        for (const chunk of chunks) {
+                            await channel.send(chunk);
+                        }
+                    }
+                    finally {
+                        // Cleanup TTS temp file
+                        if (ttsFilePath) {
+                            await fs.unlink(ttsFilePath).catch(() => { });
+                        }
+                    }
+                }
+                else {
+                    // Text path (TTS disabled)
+                    const chunks = this.chunkText(response);
+                    for (const chunk of chunks) {
+                        await channel.send(chunk);
+                    }
+                    this.display.log(`Responded to ${message.author.tag} (via audio)`, { source: 'Discord' });
                 }
-                this.display.log(`Responded to ${message.author.tag} (via audio)`, { source: 'Discord' });
             }
             processingMsg?.delete().catch(() => { });
         }

package/dist/channels/telegram.js

@@ -7,7 +7,7 @@ import os from 'os';
 import { spawn } from 'child_process';
 import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from '../runtime/display.js';
-import { createTelephonist } from '../runtime/telephonist.js';
+import { createTelephonist, createTtsTelephonist } from '../runtime/telephonist.js';
 import { getUsableApiKey } from '../runtime/trinity-crypto.js';
 import { readPid, isProcessRunning, checkStalePid } from '../runtime/lifecycle.js';
 import { SQLiteChatMessageHistory } from '../runtime/memory/sqlite.js';
@@ -173,6 +173,9 @@ export class TelegramAdapter {
     telephonist = null;
     telephonistProvider = null;
     telephonistModel = null;
+    ttsTelephonist = null;
+    ttsProvider = null;
+    ttsModel = null;
     history = new SQLiteChatMessageHistory({ sessionId: '' });
     /** Per-user session tracking — maps userId to sessionId */
     userSessions = new Map();
@@ -326,6 +329,13 @@ export class TelegramAdapter {
                     this.telephonistProvider = config.audio.provider;
                     this.telephonistModel = config.audio.model;
                 }
+                // Lazy-create TTS telephonist
+                const ttsConfig = config.audio.tts;
+                if (ttsConfig?.enabled && (!this.ttsTelephonist || this.ttsProvider !== ttsConfig.provider || this.ttsModel !== ttsConfig.model)) {
+                    this.ttsTelephonist = createTtsTelephonist(ttsConfig);
+                    this.ttsProvider = ttsConfig.provider;
+                    this.ttsModel = ttsConfig.model;
+                }
                 const duration = ctx.message.voice.duration;
                 if (duration > config.audio.maxDurationSeconds) {
                     await ctx.reply(`Voice message too long. Max duration is ${config.audio.maxDurationSeconds}s.`);
@@ -392,18 +402,108 @@ export class TelegramAdapter {
                     //   }
                     // }
                     if (response) {
-                        const rich = await toTelegramRichText(response);
-                        for (const chunk of rich.chunks) {
+                        const ttsConfig = config.audio.tts;
+                        if (ttsConfig?.enabled && this.ttsTelephonist?.synthesize) {
+                            // TTS path: synthesize and send as voice message
+                            let ttsFilePath = null;
+                            const ttsStart = Date.now();
                             try {
-                                await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                                const ttsApiKey = getUsableApiKey(ttsConfig.apiKey) ||
+                                    getUsableApiKey(config.audio.apiKey) ||
+                                    (config.llm.provider === (ttsConfig.provider === 'google' ? 'gemini' : ttsConfig.provider)
+                                        ? getUsableApiKey(config.llm.api_key) : undefined);
+                                const ttsResult = await this.ttsTelephonist.synthesize(response, ttsApiKey || '', ttsConfig.voice, ttsConfig.style_prompt);
+                                ttsFilePath = ttsResult.filePath;
+                                const ttsDurationMs = Date.now() - ttsStart;
+                                // OGG/Opus → replyWithVoice; everything else (mp3, wav) → replyWithAudio
+                                const isOgg = ttsResult.mimeType.includes('ogg') || ttsResult.mimeType.includes('opus');
+                                if (isOgg) {
+                                    await ctx.replyWithVoice({ source: ttsFilePath });
+                                }
+                                else {
+                                    await ctx.replyWithAudio({ source: ttsFilePath });
+                                }
+                                this.display.log(`Responded to @${user} (TTS audio)`, { source: 'Telegram' });
+                                // Audit TTS success
+                                try {
+                                    const auditSessionId = await this.getSessionForUser(userId);
+                                    AuditRepository.getInstance().insert({
+                                        session_id: auditSessionId,
+                                        event_type: 'telephonist',
+                                        agent: 'telephonist',
+                                        provider: ttsConfig.provider,
+                                        model: ttsConfig.model,
+                                        input_tokens: ttsResult.usage.input_tokens || null,
+                                        output_tokens: ttsResult.usage.output_tokens || null,
+                                        duration_ms: ttsDurationMs,
+                                        status: 'success',
+                                        metadata: {
+                                            operation: 'tts',
+                                            characters: response.length,
+                                            voice: ttsConfig.voice,
+                                            user,
+                                        },
+                                    });
+                                }
+                                catch {
+                                    // Audit failure never breaks the main flow
+                                }
                             }
-                            catch {
-                                const plain = stripHtmlTags(chunk).slice(0, 4096);
-                                if (plain)
-                                    await ctx.reply(plain);
+                            catch (ttsError) {
+                                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
+                                try {
+                                    const auditSessionId = await this.getSessionForUser(userId);
+                                    AuditRepository.getInstance().insert({
+                                        session_id: auditSessionId,
+                                        event_type: 'telephonist',
+                                        agent: 'telephonist',
+                                        provider: ttsConfig.provider,
+                                        model: ttsConfig.model,
+                                        duration_ms: Date.now() - ttsStart,
+                                        status: 'error',
+                                        metadata: { operation: 'tts', error: ttsDetail, user },
+                                    });
+                                }
+                                catch {
+                                    // Audit failure never breaks the main flow
+                                }
+                                // Fallback to text
+                                const rich = await toTelegramRichText(response);
+                                for (const chunk of rich.chunks) {
+                                    try {
+                                        await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                                    }
+                                    catch {
+                                        const plain = stripHtmlTags(chunk).slice(0, 4096);
+                                        if (plain)
+                                            await ctx.reply(plain);
+                                    }
+                                }
+                            }
+                            finally {
+                                // Cleanup TTS temp file
+                                if (ttsFilePath) {
+                                    await fs.promises.unlink(ttsFilePath).catch(() => { });
+                                }
+                            }
+                        }
+                        else {
+                            // Text path (TTS disabled)
+                            const rich = await toTelegramRichText(response);
+                            for (const chunk of rich.chunks) {
+                                try {
+                                    await ctx.reply(chunk, { parse_mode: rich.parse_mode });
+                                }
+                                catch {
+                                    const plain = stripHtmlTags(chunk).slice(0, 4096);
+                                    if (plain)
+                                        await ctx.reply(plain);
+                                }
                             }
+                            this.display.log(`Responded to @${user} (via audio)`, { source: 'Telegram' });
                         }
-                        this.display.log(`Responded to @${user} (via audio)`, { source: 'Telegram' });
                     }
                 }
                 catch (error) {

package/dist/cli/commands/start.js

@@ -28,6 +28,12 @@ import { MCPToolCache } from '../../runtime/tools/cache.js';
 import { SmithRegistry } from '../../runtime/smiths/registry.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';
 // Load .env file explicitly in start command
 const envPath = path.join(process.cwd(), '.env');
 if (fs.existsSync(envPath)) {
@@ -214,6 +220,15 @@ 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/config/manager.js

@@ -284,13 +284,27 @@ export class ConfigManager {
         const audioProvider = resolveString('MORPHEUS_AUDIO_PROVIDER', config.audio.provider, DEFAULT_CONFIG.audio.provider);
         // AudioProvider uses 'google' but resolveApiKey expects LLMProvider which uses 'gemini'
         const audioProviderForKey = (audioProvider === 'google' ? 'gemini' : audioProvider);
+        // TTS config
+        const ttsDefaults = DEFAULT_CONFIG.audio.tts;
+        const ttsCfg = config.audio.tts;
+        const ttsProvider = resolveString('MORPHEUS_AUDIO_TTS_PROVIDER', ttsCfg?.provider, ttsDefaults.provider);
+        const ttsProviderForKey = (ttsProvider === 'google' ? 'gemini' : ttsProvider);
+        const ttsConfig = {
+            enabled: resolveBoolean('MORPHEUS_AUDIO_TTS_ENABLED', ttsCfg?.enabled, ttsDefaults.enabled),
+            provider: ttsProvider,
+            model: resolveString('MORPHEUS_AUDIO_TTS_MODEL', ttsCfg?.model, ttsDefaults.model),
+            voice: resolveString('MORPHEUS_AUDIO_TTS_VOICE', ttsCfg?.voice, ttsDefaults.voice),
+            apiKey: resolveApiKey(ttsProviderForKey, 'MORPHEUS_AUDIO_TTS_API_KEY', ttsCfg?.apiKey),
+            style_prompt: resolveString('MORPHEUS_AUDIO_TTS_STYLE_PROMPT', ttsCfg?.style_prompt, ''),
+        };
         const audioConfig = {
             provider: audioProvider,
             model: resolveString('MORPHEUS_AUDIO_MODEL', config.audio.model, DEFAULT_CONFIG.audio.model),
             enabled: resolveBoolean('MORPHEUS_AUDIO_ENABLED', config.audio.enabled, DEFAULT_CONFIG.audio.enabled),
             apiKey: resolveApiKey(audioProviderForKey, 'MORPHEUS_AUDIO_API_KEY', config.audio.apiKey),
             maxDurationSeconds: resolveNumeric('MORPHEUS_AUDIO_MAX_DURATION', config.audio.maxDurationSeconds, DEFAULT_CONFIG.audio.maxDurationSeconds),
-            supportedMimeTypes: config.audio.supportedMimeTypes
+            supportedMimeTypes: config.audio.supportedMimeTypes,
+            tts: ttsConfig,
         };
         // Apply precedence to channel configs
         const channelsConfig = {
@@ -376,6 +390,11 @@ export class ConfigManager {
                 enabled: resolveBoolean('MORPHEUS_SETUP_ENABLED', config.setup?.enabled, true),
                 fields: config.setup?.fields ?? ['name', 'timezone', 'preferred_language'],
             },
+            currency: {
+                code: resolveString('MORPHEUS_CURRENCY_CODE', config.currency?.code, 'USD'),
+                symbol: resolveString('MORPHEUS_CURRENCY_SYMBOL', config.currency?.symbol, '$'),
+                rate: resolveNumeric('MORPHEUS_CURRENCY_RATE', config.currency?.rate, 1.0),
+            },
         };
     }
     get() {

package/dist/config/paths.js

@@ -16,4 +16,8 @@ export const PATHS = {
     mcps: path.join(MORPHEUS_ROOT, 'mcps.json'),
     skills: path.join(MORPHEUS_ROOT, 'skills'),
     docs: path.join(MORPHEUS_ROOT, 'docs'),
+    shortMemoryDb: path.join(MORPHEUS_ROOT, 'memory', 'short-memory.db'),
+    trinityDb: path.join(MORPHEUS_ROOT, 'memory', 'trinity.db'),
+    satiDb: path.join(MORPHEUS_ROOT, 'memory', 'sati-memory.db'),
+    linkDb: path.join(MORPHEUS_ROOT, 'memory', 'link.db'),
 };

package/dist/config/schemas.js

@@ -1,5 +1,13 @@
 import { z } from 'zod';
 import { DEFAULT_CONFIG } from '../types/config.js';
+export const TtsConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    provider: z.enum(['openai', 'google']).default('google'),
+    model: z.string().min(1).default('gemini-2.5-flash-preview-tts'),
+    voice: z.string().min(1).default('Kore'),
+    apiKey: z.string().optional(),
+    style_prompt: z.string().optional(),
+});
 export const AudioConfigSchema = z.object({
     provider: z.enum(['google', 'openai', 'openrouter', 'ollama']).default(DEFAULT_CONFIG.audio.provider),
     model: z.string().min(1).default(DEFAULT_CONFIG.audio.model),
@@ -8,6 +16,7 @@ export const AudioConfigSchema = z.object({
     base_url: z.string().optional(),
     maxDurationSeconds: z.number().default(DEFAULT_CONFIG.audio.maxDurationSeconds),
     supportedMimeTypes: z.array(z.string()).default(DEFAULT_CONFIG.audio.supportedMimeTypes),
+    tts: TtsConfigSchema.optional(),
 });
 export const LLMConfigSchema = z.object({
     provider: z.enum(['openai', 'anthropic', 'openrouter', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
@@ -84,6 +93,11 @@ export const SmithsConfigSchema = z.object({
     task_timeout_ms: z.number().int().min(1000).default(60000),
     entries: z.array(SmithEntrySchema).default([]),
 });
+export const CurrencyConfigSchema = z.object({
+    code: z.string().min(1).default('USD'),
+    symbol: z.string().min(1).default('$'),
+    rate: z.number().positive().default(1.0),
+});
 // Zod Schema matching MorpheusConfig interface
 export const ConfigSchema = z.object({
     agent: z.object({
@@ -110,6 +124,7 @@ export const ConfigSchema = z.object({
     devkit: DevKitConfigSchema.optional(),
     smiths: SmithsConfigSchema.optional(),
     setup: SetupConfigSchema.optional(),
+    currency: CurrencyConfigSchema.optional(),
     verbose_mode: z.boolean().default(true),
     channels: z.object({
         telegram: z.object({

package/dist/http/api.js

@@ -238,8 +238,9 @@ export function createApiRouter(oracle, chronosWorker) {
             const offset = parseInt(req.query.offset) || 0;
             const audit = AuditRepository.getInstance();
             const events = audit.getBySession(id, { limit, offset });
+            const total_count = audit.countBySession(id);
             const summary = audit.getSessionSummary(id);
-            res.json({ events, summary });
+            res.json({ events, summary, total_count });
         }
         catch (err) {
             res.status(500).json({ error: err.message });

package/dist/http/routers/danger.js

@@ -1,8 +1,7 @@
 import { Router } from 'express';
 import Database from 'better-sqlite3';
-import path from 'path';
-import { homedir } from 'os';
 import fs from 'fs-extra';
+import { PATHS } from '../../config/paths.js';
 import { z } from 'zod';
 import { SatiRepository } from '../../runtime/memory/sati/repository.js';
 import { DisplayManager } from '../../runtime/display.js';
@@ -51,9 +50,9 @@ export function createDangerRouter() {
         }
         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 memoryDir = PATHS.memory;
+            const shortMemoryPath = PATHS.shortMemoryDb;
+            const satiMemoryPath = PATHS.satiDb;
             const counts = {};
             // ─── 1. Purge short-memory.db tables based on selected categories ───
             const needsShortDb = categories.some((c) => ['sessions', 'tasks', 'audit', 'chronos', 'webhooks'].includes(c));

package/dist/http/routers/link.js

@@ -2,11 +2,11 @@ import { Router } from 'express';
 import multer from 'multer';
 import path from 'path';
 import fs from 'fs-extra';
-import { homedir } from 'os';
 import { LinkRepository } from '../../runtime/subagents/link/repository.js';
 import { LinkWorker } from '../../runtime/subagents/link/worker.js';
 import { ConfigManager } from '../../config/manager.js';
-const DOCS_PATH = path.join(homedir(), '.morpheus', 'docs');
+import { PATHS } from '../../config/paths.js';
+const DOCS_PATH = PATHS.docs;
 // Configure multer for file uploads
 const storage = multer.diskStorage({
     destination: async (req, file, cb) => {