morpheus-cli 0.1.10 → 0.1.11

package/dist/channels/__tests__/telegram.test.js

@@ -28,12 +28,12 @@ vi.mock('../../runtime/display.js', () => ({
 }));
 describe('TelegramAdapter', () => {
     let adapter;
-    let mockAgent;
+    let mockOracle;
     beforeEach(() => {
-        mockAgent = {
+        mockOracle = {
             chat: vi.fn(),
         };
-        adapter = new TelegramAdapter(mockAgent);
+        adapter = new TelegramAdapter(mockOracle);
     });
     afterEach(() => {
         vi.clearAllMocks();

package/dist/channels/telegram.js

@@ -6,16 +6,16 @@ import path from 'path';
 import os from 'os';
 import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from '../runtime/display.js';
-import { AudioAgent } from '../runtime/audio-agent.js';
+import { Telephonist } from '../runtime/telephonist.js';
 export class TelegramAdapter {
     bot = null;
     isConnected = false;
     display = DisplayManager.getInstance();
     config = ConfigManager.getInstance();
-    agent;
-    audioAgent = new AudioAgent();
-    constructor(agent) {
-        this.agent = agent;
+    oracle;
+    telephonist = new Telephonist();
+    constructor(oracle) {
+        this.oracle = oracle;
     }
     async connect(token, allowedUsers) {
         if (this.isConnected) {
@@ -44,7 +44,7 @@ export class TelegramAdapter {
                     // Send "typing" status
                     await ctx.sendChatAction('typing');
                     // Process with Agent
-                    const response = await this.agent.chat(text);
+                    const response = await this.oracle.chat(text);
                     if (response) {
                         await ctx.reply(response);
                         this.display.log(`Responded to @${user}`, { source: 'Telegram' });
@@ -76,7 +76,7 @@ export class TelegramAdapter {
                 }
                 const apiKey = config.audio.apiKey || (config.llm.provider === 'gemini' ? config.llm.api_key : undefined);
                 if (!apiKey) {
-                    this.display.log(`Audio transcription failed: No Gemini API key available`, { source: 'AgentAudio', level: 'error' });
+                    this.display.log(`Audio transcription failed: No Gemini API key available`, { source: 'Telephonist', level: 'error' });
                     await ctx.reply("Audio transcription requires a Gemini API key. Please configure `audio.apiKey` or set LLM provider to Gemini.");
                     return;
                 }
@@ -85,19 +85,19 @@ export class TelegramAdapter {
                     await ctx.reply(`Voice message too long. Max duration is ${config.audio.maxDurationSeconds}s.`);
                     return;
                 }
-                this.display.log(`Receiving voice message from @${user} (${duration}s)...`, { source: 'AgentAudio' });
+                this.display.log(`Receiving voice message from @${user} (${duration}s)...`, { source: 'Telephonist' });
                 let filePath = null;
                 let listeningMsg = null;
                 try {
                     listeningMsg = await ctx.reply("🎧Escutando...");
                     // Download
-                    this.display.log(`Downloading audio for @${user}...`, { source: 'AgentAudio' });
+                    this.display.log(`Downloading audio for @${user}...`, { source: 'Telephonist' });
                     const fileLink = await ctx.telegram.getFileLink(ctx.message.voice.file_id);
                     filePath = await this.downloadToTemp(fileLink);
                     // Transcribe
-                    this.display.log(`Transcribing audio for @${user}...`, { source: 'AgentAudio' });
-                    const { text, usage } = await this.audioAgent.transcribe(filePath, 'audio/ogg', apiKey);
-                    this.display.log(`Transcription success for @${user}: "${text}"`, { source: 'AgentAudio', level: 'success' });
+                    this.display.log(`Transcribing audio for @${user}...`, { source: 'Telephonist' });
+                    const { text, usage } = await this.telephonist.transcribe(filePath, 'audio/ogg', apiKey);
+                    this.display.log(`Transcription success for @${user}: "${text}"`, { source: 'Telephonist', level: 'success' });
                     // Reply with transcription (optional, maybe just process it?)
                     // The prompt says "reply with the answer".
                     // "Transcribe them... and process the resulting text as a standard user prompt."
@@ -105,7 +105,7 @@ export class TelegramAdapter {
                     await ctx.reply(`🎤 *Transcription*: _"${text}"_`, { parse_mode: 'Markdown' });
                     await ctx.sendChatAction('typing');
                     // Process with Agent
-                    const response = await this.agent.chat(text, usage);
+                    const response = await this.oracle.chat(text, usage);
                     // if (listeningMsg) {
                     //   try {
                     //     await ctx.telegram.deleteMessage(ctx.chat.id, listeningMsg.message_id);
@@ -119,7 +119,7 @@ export class TelegramAdapter {
                     }
                 }
                 catch (error) {
-                    this.display.log(`Audio processing error for @${user}: ${error.message}`, { source: 'AgentAudio', level: 'error' });
+                    this.display.log(`Audio processing error for @${user}: ${error.message}`, { source: 'Telephonist', level: 'error' });
                     await ctx.reply("Sorry, I failed to process your audio message.");
                 }
                 finally {

package/dist/cli/commands/start.js

@@ -8,7 +8,7 @@ import { ConfigManager } from '../../config/manager.js';
 import { renderBanner } from '../utils/render.js';
 import { TelegramAdapter } from '../../channels/telegram.js';
 import { PATHS } from '../../config/paths.js';
-import { Agent } from '../../runtime/agent.js';
+import { Oracle } from '../../runtime/oracle.js';
 import { ProviderError } from '../../runtime/errors.js';
 import { HttpServer } from '../../http/server.js';
 export const startCommand = new Command('start')
@@ -45,13 +45,13 @@ export const startCommand = new Command('start')
         if (options.ui) {
             display.log(chalk.blue(`Web UI enabled to port ${options.port}`));
         }
-        // Initialize Agent
-        const agent = new Agent(config);
+        // Initialize Oracle
+        const oracle = new Oracle(config);
         try {
-            display.startSpinner(`Initializing ${config.llm.provider} agent...`);
-            await agent.initialize();
+            display.startSpinner(`Initializing ${config.llm.provider} oracle...`);
+            await oracle.initialize();
             display.stopSpinner();
-            display.log(chalk.green('✓ Agent initialized'), { source: 'Agent' });
+            display.log(chalk.green('✓ Oracle initialized'), { source: 'Oracle' });
         }
         catch (err) {
             display.stopSpinner();
@@ -63,7 +63,7 @@ export const startCommand = new Command('start')
                 }
             }
             else {
-                display.log(chalk.red('\nAgent initialization failed:'));
+                display.log(chalk.red('\nOracle initialization failed:'));
                 display.log(chalk.white(err.message));
                 if (err.message.includes('API Key')) {
                     display.log(chalk.yellow('Tip: Check your API key in configuration or environment variables.'));
@@ -89,7 +89,7 @@ export const startCommand = new Command('start')
         // Initialize Telegram
         if (config.channels.telegram.enabled) {
             if (config.channels.telegram.token) {
-                const telegram = new TelegramAdapter(agent);
+                const telegram = new TelegramAdapter(oracle);
                 try {
                     await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
                     adapters.push(telegram);

package/dist/config/manager.js

@@ -4,6 +4,7 @@ import { DEFAULT_CONFIG } from '../types/config.js';
 import { PATHS } from './paths.js';
 import { setByPath } from './utils.js';
 import { ConfigSchema } from './schemas.js';
+import { migrateConfigFile } from '../runtime/migration.js';
 export class ConfigManager {
     static instance;
     config = DEFAULT_CONFIG;
@@ -16,6 +17,7 @@ export class ConfigManager {
     }
     async load() {
         try {
+            await migrateConfigFile();
             if (await fs.pathExists(PATHS.config)) {
                 const raw = await fs.readFile(PATHS.config, 'utf8');
                 const parsed = yaml.load(raw);

package/dist/config/mcp-loader.js

@@ -17,7 +17,7 @@ export async function loadMCPConfig() {
         rawConfig = JSON.parse(content);
     }
     catch (err) {
-        display.log(`Failed to parse mcps.json: ${err.message}`, { level: 'error', source: 'Config' });
+        display.log(`Failed to parse mcps.json: ${err.message}`, { level: 'error', source: 'Zaion' });
         return servers;
     }
     // Filter metadata keys (starting with _ or $) and the "example" template key
@@ -26,15 +26,15 @@ export async function loadMCPConfig() {
         try {
             const validated = MCPServerConfigSchema.parse(config);
             servers[name] = validated;
-            display.log(`Loaded MCP server: ${name}`, { level: 'debug', source: 'Config' });
+            display.log(`Loaded MCP server: ${name}`, { level: 'debug', source: 'Zaion' });
         }
         catch (err) {
             if (err instanceof z.ZodError) {
                 const issues = err.issues.map(i => i.message).join(', ');
-                display.log(`Invalid MCP server '${name}': ${issues}`, { level: 'warning', source: 'Config' });
+                display.log(`Invalid MCP server '${name}': ${issues}`, { level: 'warning', source: 'Zaion' });
             }
             else {
-                display.log(`Invalid MCP server '${name}': ${err.message}`, { level: 'warning', source: 'Config' });
+                display.log(`Invalid MCP server '${name}': ${err.message}`, { level: 'warning', source: 'Zaion' });
             }
         }
     }

package/dist/config/paths.js

@@ -5,7 +5,8 @@ export const MORPHEUS_ROOT = path.join(USER_HOME, '.morpheus');
 export const LOGS_DIR = path.join(MORPHEUS_ROOT, 'logs');
 export const PATHS = {
     root: MORPHEUS_ROOT,
-    config: path.join(MORPHEUS_ROOT, 'config.yaml'),
+    config: path.join(MORPHEUS_ROOT, 'zaion.yaml'),
+    legacyConfig: path.join(MORPHEUS_ROOT, 'config.yaml'),
     pid: path.join(MORPHEUS_ROOT, 'morpheus.pid'),
     logs: LOGS_DIR,
     memory: path.join(MORPHEUS_ROOT, 'memory'),

package/dist/http/api.js

@@ -98,7 +98,7 @@ export function createApiRouter() {
             if (changes.length > 0) {
                 const display = DisplayManager.getInstance();
                 display.log(`Configuration updated via UI:\n  - ${changes.join('\n  - ')}`, {
-                    source: 'Config',
+                    source: 'Zaion',
                     level: 'info'
                 });
             }

package/dist/runtime/__tests__/manual_start_verify.js

@@ -1,4 +1,4 @@
-import { Agent } from '../agent.js';
+import { Oracle } from '../oracle.js';
 import chalk from 'chalk';
 const start = Date.now();
 console.log(chalk.blue('Running Manual Start Verification...'));
@@ -23,19 +23,19 @@ const mockConfig = {
 };
 const run = async () => {
     try {
-        console.log(chalk.gray('1. Instantiating Agent...'));
-        const agent = new Agent(mockConfig);
-        console.log(chalk.gray('2. Initializing Agent...'));
-        await agent.initialize();
+        console.log(chalk.gray('1. Instantiating Oracle...'));
+        const oracle = new Oracle(mockConfig);
+        console.log(chalk.gray('2. Initializing Oracle...'));
+        await oracle.initialize();
         const duration = (Date.now() - start) / 1000;
-        console.log(chalk.green(`✓ Agent initialized successfully in ${duration}s`));
+        console.log(chalk.green(`✓ Oracle initialized successfully in ${duration}s`));
         if (duration > 5) {
             console.log(chalk.red(`✗ Startup took too long (> 5s)`));
             process.exit(1);
         }
         console.log(chalk.gray('3. Testing Initialization Check...'));
         try {
-            await agent.chat('Hello');
+            await oracle.chat('Hello');
             // This might fail if using real network, but we just want to ensure it tries
         }
         catch (e) {

package/dist/runtime/__tests__/manual_us1.js

@@ -1,4 +1,4 @@
-import { Agent } from '../agent.js';
+import { Oracle } from '../oracle.js';
 import { DEFAULT_CONFIG } from '../../types/config.js';
 // Verify environment requirements
 if (!process.env.OPENAI_API_KEY) {
@@ -15,12 +15,12 @@ const manualConfig = {
     }
 };
 async function run() {
-    console.log("Initializing Agent...");
-    const agent = new Agent(manualConfig);
-    await agent.initialize();
+    console.log("Initializing Oracle...");
+    const oracle = new Oracle(manualConfig);
+    await oracle.initialize();
     console.log("Sending message: 'Hello, are you there?'");
     try {
-        const response = await agent.chat("Hello, are you there?");
+        const response = await oracle.chat("Hello, are you there?");
         console.log("Response received:");
         console.log("---------------------------------------------------");
         console.log(response);

package/dist/runtime/__tests__/oracle.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Oracle } from '../oracle.js';
+import { ProviderFactory } from '../providers/factory.js';
+import { Construtor } from '../tools/factory.js';
+import { DEFAULT_CONFIG } from '../../types/config.js';
+import { AIMessage } from '@langchain/core/messages';
+import * as path from 'path';
+import { tmpdir } from 'os';
+vi.mock('../providers/factory.js');
+vi.mock('../tools/factory.js');
+describe('Oracle', () => {
+    let oracle;
+    let testDbPath;
+    const mockProvider = {
+        invoke: vi.fn(),
+    };
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        // Use temp DB
+        testDbPath = path.join(tmpdir(), `test-oracle-${Date.now()}.db`);
+        mockProvider.invoke.mockImplementation(async ({ messages }) => {
+            return {
+                messages: [...messages, new AIMessage('Hello world')]
+            };
+        });
+        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
+        vi.mocked(Construtor.create).mockResolvedValue([]);
+        oracle = new Oracle(DEFAULT_CONFIG, { databasePath: testDbPath });
+    });
+    afterEach(async () => {
+        // Clean up after each test
+        if (oracle) {
+            try {
+                await oracle.clearMemory();
+            }
+            catch (err) {
+                // Ignore cleanup errors
+            }
+        }
+    });
+    it('should initialize successfully', async () => {
+        await oracle.initialize();
+        expect(Construtor.create).toHaveBeenCalled();
+        expect(ProviderFactory.create).toHaveBeenCalledWith(DEFAULT_CONFIG.llm, []);
+    });
+    it('should chat successfully', async () => {
+        await oracle.initialize();
+        const response = await oracle.chat('Hi');
+        expect(response).toBe('Hello world');
+        expect(mockProvider.invoke).toHaveBeenCalled();
+    });
+    it('should throw if not initialized', async () => {
+        await expect(oracle.chat('Hi')).rejects.toThrow('initialize() first');
+    });
+    it('should maintain history', async () => {
+        await oracle.initialize();
+        // Clear any residual history from previous tests
+        await oracle.clearMemory();
+        // First turn
+        await oracle.chat('Hi');
+        const history1 = await oracle.getHistory();
+        expect(history1).toHaveLength(2);
+        expect(history1[0].content).toBe('Hi'); // User
+        expect(history1[1].content).toBe('Hello world'); // AI
+        // Second turn
+        // Update mock return value for next call
+        mockProvider.invoke.mockImplementation(async ({ messages }) => {
+            return {
+                messages: [...messages, new AIMessage('I am fine')]
+            };
+        });
+        await oracle.chat('How are you?');
+        const history2 = await oracle.getHistory();
+        expect(history2).toHaveLength(4);
+        expect(history2[2].content).toBe('How are you?');
+        expect(history2[3].content).toBe('I am fine');
+    });
+    describe('Configuration Validation', () => {
+        it('should throw if llm provider is missing', async () => {
+            const invalidConfig = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+            delete invalidConfig.llm.provider; // Invalid
+            const badOracle = new Oracle(invalidConfig);
+            await expect(badOracle.initialize()).rejects.toThrow('LLM provider not specified');
+        });
+        it('should propagate ProviderError during initialization', async () => {
+            const mockError = new Error("Mock Factory Error");
+            vi.mocked(ProviderFactory.create).mockImplementation(() => { throw mockError; });
+            // ProviderError constructs message as: "Provider {provider} failed: {originalError.message}"
+            await expect(oracle.initialize()).rejects.toThrow('Provider openai failed: Mock Factory Error');
+        });
+    });
+});

package/dist/runtime/__tests__/oracle_memory_limit.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Oracle } from '../oracle.js';
+import { ProviderFactory } from '../providers/factory.js';
+import { DEFAULT_CONFIG } from '../../types/config.js';
+import { AIMessage } from '@langchain/core/messages';
+import * as path from 'path';
+import { tmpdir } from 'os';
+vi.mock('../providers/factory.js');
+describe('Oracle Memory Limit', () => {
+    let oracle;
+    const mockProvider = {
+        invoke: vi.fn(),
+    };
+    let dbPath;
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        dbPath = path.join(tmpdir(), `test-oracle-limit-${Date.now()}.db`);
+        mockProvider.invoke.mockImplementation(async ({ messages }) => {
+            return {
+                messages: [...messages, new AIMessage('Response')]
+            };
+        });
+        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
+    });
+    afterEach(async () => {
+        if (oracle) {
+            try {
+                await oracle.clearMemory();
+            }
+            catch (err) { }
+        }
+    });
+    it('should respect configured memory limit', async () => {
+        const limitedConfig = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+        limitedConfig.memory.limit = 2; // Only last 2 messages (1 exchange)
+        oracle = new Oracle(limitedConfig, { databasePath: dbPath });
+        await oracle.initialize();
+        // Turn 1
+        await oracle.chat('Msg 1');
+        // Turn 2
+        await oracle.chat('Msg 2');
+        // Turn 3
+        await oracle.chat('Msg 3');
+        // DB should have 6 messages (3 User + 3 AI)
+        // getHistory() should return only 2 (User Msg 3 + AI Response)
+        // Wait, SQLiteChatMessageHistory limit might be total messages? Or pairs?
+        // LangChain's limit usually means "last N messages".
+        const history = await oracle.getHistory();
+        // Assuming limit=2 means 2 messages.
+        expect(history.length).toBeLessThanOrEqual(2);
+        expect(history[history.length - 1].content).toBe('Response');
+    });
+});

package/dist/runtime/__tests__/oracle_persistence.test.js

@@ -0,0 +1,154 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { Oracle } from "../oracle.js";
+import { ProviderFactory } from "../providers/factory.js";
+import { DEFAULT_CONFIG } from "../../types/config.js";
+import { AIMessage } from "@langchain/core/messages";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { tmpdir } from "os";
+import { Construtor } from "../tools/factory.js";
+vi.mock("../providers/factory.js");
+vi.mock("../tools/factory.js");
+describe("Oracle Persistence Integration", () => {
+    let oracle;
+    let testDbPath;
+    let tempDir;
+    const mockProvider = {
+        invoke: vi.fn(),
+    };
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        // Create a unique temporary test database path for each test to avoid interference
+        tempDir = path.join(tmpdir(), "morpheus-test-agent", Date.now().toString() + Math.random().toString(36).substring(7));
+        testDbPath = path.join(tempDir, "short-memory.db");
+        mockProvider.invoke.mockImplementation(async ({ messages }) => {
+            return {
+                messages: [...messages, new AIMessage("Test response")]
+            };
+        });
+        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
+        vi.mocked(Construtor.create).mockResolvedValue([]);
+        oracle = new Oracle(DEFAULT_CONFIG, { databasePath: testDbPath });
+    });
+    afterEach(async () => {
+        // Clean up temporary test directory
+        if (fs.existsSync(tempDir)) {
+            try {
+                fs.removeSync(tempDir);
+            }
+            catch (err) {
+                // Ignore removal errors if file is locked
+            }
+        }
+    });
+    describe("Database File Creation", () => {
+        it("should create database file on initialization", async () => {
+            await oracle.initialize();
+            expect(fs.existsSync(testDbPath)).toBe(true);
+        });
+    });
+    describe("Message Persistence", () => {
+        it("should persist messages to database", async () => {
+            await oracle.initialize();
+            // Send a message
+            await oracle.chat("Hello, Oracle!");
+            // Verify history contains the message
+            const history = await oracle.getHistory();
+            expect(history).toHaveLength(2); // User message + AI response
+            expect(history[0].content).toBe("Hello, Oracle!");
+            expect(history[1].content).toBe("Test response");
+        });
+        it("should restore conversation history on restart", async () => {
+            // First session: send a message
+            await oracle.initialize();
+            await oracle.chat("Remember this message");
+            const firstHistory = await oracle.getHistory();
+            expect(firstHistory).toHaveLength(2);
+            // Simulate restart: create new oracle instance with SAME database path
+            const oracle2 = new Oracle(DEFAULT_CONFIG, { databasePath: testDbPath });
+            await oracle2.initialize();
+            // Verify history was restored
+            const restoredHistory = await oracle2.getHistory();
+            expect(restoredHistory.length).toBeGreaterThanOrEqual(2);
+            // Check that the old messages are present
+            const contents = restoredHistory.map(m => m.content);
+            expect(contents).toContain("Remember this message");
+            expect(contents).toContain("Test response");
+        });
+        it("should accumulate messages across multiple conversations", async () => {
+            await oracle.initialize();
+            // First conversation
+            await oracle.chat("First message");
+            // Second conversation
+            mockProvider.invoke.mockImplementation(async ({ messages }) => {
+                return {
+                    messages: [...messages, new AIMessage("Second response")]
+                };
+            });
+            await oracle.chat("Second message");
+            // Verify all messages are persisted
+            const history = await oracle.getHistory();
+            expect(history).toHaveLength(4);
+            expect(history[0].content).toBe("First message");
+            expect(history[1].content).toBe("Test response");
+            expect(history[2].content).toBe("Second message");
+            expect(history[3].content).toBe("Second response");
+        });
+    });
+    describe("Memory Clearing", () => {
+        it("should clear all persisted messages", async () => {
+            await oracle.initialize();
+            // Add some messages
+            await oracle.chat("Message 1");
+            await oracle.chat("Message 2");
+            // Verify messages exist
+            let history = await oracle.getHistory();
+            expect(history.length).toBeGreaterThan(0);
+            // Clear memory
+            await oracle.clearMemory();
+            // Verify messages are cleared
+            history = await oracle.getHistory();
+            expect(history).toEqual([]);
+        });
+        it("should start fresh after clearing memory", async () => {
+            await oracle.initialize();
+            // Add and clear messages
+            await oracle.chat("Old message");
+            await oracle.clearMemory();
+            // Add new message
+            mockProvider.invoke.mockImplementation(async ({ messages }) => {
+                return {
+                    messages: [...messages, new AIMessage("New response")]
+                };
+            });
+            await oracle.chat("New message");
+            // Verify only new messages exist
+            const history = await oracle.getHistory();
+            expect(history).toHaveLength(2);
+            expect(history[0].content).toBe("New message");
+            expect(history[1].content).toBe("New response");
+        });
+    });
+    describe("Context Preservation", () => {
+        it("should include history in conversation context", async () => {
+            await oracle.initialize();
+            // First message
+            await oracle.chat("My name is Alice");
+            // Second message (should have context)
+            mockProvider.invoke.mockImplementation(async ({ messages }) => {
+                return {
+                    messages: [...messages, new AIMessage("Hello Alice!")]
+                };
+            });
+            await oracle.chat("What is my name?");
+            // Verify the provider was called with full history
+            const lastCall = mockProvider.invoke.mock.calls[1];
+            const messagesPassedToLLM = lastCall[0].messages;
+            // Should include: system message, previous user message, previous AI response, new user message
+            expect(messagesPassedToLLM.length).toBeGreaterThanOrEqual(4);
+            // Check that context includes the original message
+            const contents = messagesPassedToLLM.map((m) => m.content);
+            expect(contents).toContain("My name is Alice");
+        });
+    });
+});

package/dist/runtime/display.js

@@ -77,22 +77,22 @@ export class DisplayManager {
             if (options.source === 'Telegram') {
                 color = chalk.green;
             }
-            else if (options.source === 'Agent') {
+            else if (options.source === 'Oracle') {
                 color = chalk.hex('#FFA500');
             }
-            else if (options.source === 'AgentAudio') {
+            else if (options.source === 'Telephonist') {
                 color = chalk.hex('#b902b9');
             }
-            else if (options.source === 'ToolsFactory') {
+            else if (options.source === 'Construtor') {
                 color = chalk.hex('#806d00');
             }
             else if (options.source === 'MCPServer') {
                 color = chalk.hex('#be4b1d');
             }
-            else if (options.source === 'ToolCall') {
+            else if (options.source === 'ConstructLoad') {
                 color = chalk.hex('#e5ff00');
             }
-            else if (options.source === 'Config') {
+            else if (options.source === 'Zaion') {
                 color = chalk.hex('#00c3ff');
             }
             prefix = color(`[${options.source}] `);

package/dist/runtime/migration.js

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { PATHS } from '../config/paths.js';
+import { DisplayManager } from './display.js';
+export async function migrateConfigFile() {
+    const display = DisplayManager.getInstance();
+    const legacyPath = PATHS.legacyConfig ?? path.join(PATHS.root, 'config.yaml');
+    const newPath = PATHS.config;
+    const legacyExists = await fs.pathExists(legacyPath);
+    const newExists = await fs.pathExists(newPath);
+    if (legacyExists && !newExists) {
+        try {
+            await fs.ensureDir(PATHS.root);
+            await fs.move(legacyPath, newPath, { overwrite: false });
+            display.log('Migrated config.yaml to zaion.yaml', { source: 'Zaion', level: 'info' });
+        }
+        catch (err) {
+            display.log(`Failed to migrate config.yaml to zaion.yaml: ${err.message}`, { source: 'Zaion', level: 'warning' });
+        }
+        return;
+    }
+    if (legacyExists && newExists) {
+        display.log('Both config.yaml and zaion.yaml exist. Using zaion.yaml and leaving config.yaml in place.', {
+            source: 'Zaion',
+            level: 'warning'
+        });
+    }
+}

package/dist/runtime/oracle.js

@@ -0,0 +1,229 @@
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { ProviderFactory } from "./providers/factory.js";
+import { Construtor } from "./tools/factory.js";
+import { ConfigManager } from "../config/manager.js";
+import { ProviderError } from "./errors.js";
+import { DisplayManager } from "./display.js";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+export class Oracle {
+    provider;
+    config;
+    history;
+    display = DisplayManager.getInstance();
+    databasePath;
+    constructor(config, overrides) {
+        this.config = config || ConfigManager.getInstance().get();
+        this.databasePath = overrides?.databasePath;
+    }
+    async initialize() {
+        if (!this.config.llm) {
+            throw new Error("LLM configuration missing in config object.");
+        }
+        // Basic validation before provider creation
+        if (!this.config.llm.provider) {
+            throw new Error("LLM provider not specified in configuration.");
+        }
+        // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
+        // to allow for Environment Variable fallback supported by LangChain.
+        try {
+            const tools = await Construtor.create();
+            this.provider = await ProviderFactory.create(this.config.llm, tools);
+            if (!this.provider) {
+                throw new Error("Provider factory returned undefined");
+            }
+            // Initialize persistent memory with SQLite
+            this.history = new SQLiteChatMessageHistory({
+                sessionId: "default",
+                databasePath: this.databasePath,
+                limit: this.config.memory?.limit || 100, // Fallback purely defensive if config type allows optional
+            });
+        }
+        catch (err) {
+            if (err instanceof ProviderError)
+                throw err; // Re-throw known errors
+            // Wrap unknown errors
+            throw new ProviderError(this.config.llm.provider || 'unknown', err, "Oracle initialization failed");
+        }
+    }
+    async chat(message, extraUsage) {
+        if (!this.provider) {
+            throw new Error("Oracle not initialized. Call initialize() first.");
+        }
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        try {
+            this.display.log('Processing message...', { source: 'Oracle' });
+            const userMessage = new HumanMessage(message);
+            // Inject provider/model metadata for persistence
+            userMessage.provider_metadata = {
+                provider: this.config.llm.provider,
+                model: this.config.llm.model
+            };
+            // Attach extra usage (e.g. from Audio) to the user message to be persisted
+            if (extraUsage) {
+                userMessage.usage_metadata = extraUsage;
+            }
+            const systemMessage = new SystemMessage(`
+You are  ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
+
+Your role is to orchestrate tools, MCPs, and language models to accurately fulfill the Architect’s request.
+
+You are an operator, not a guesser.
+Accuracy, verification, and task completion are more important than speed.
+
+--------------------------------------------------
+CORE OPERATING PRINCIPLES
+--------------------------------------------------
+
+1. TOOL EVALUATION FIRST
+
+Before generating any final answer, evaluate whether an available tool or MCP can provide a more accurate, up-to-date, or authoritative result.
+
+If a tool can provide the answer, you MUST call the tool.
+
+Never generate speculative values when a tool can verify them.
+
+
+2. ACTIVE INTENT TRACKING (CRITICAL)
+
+You must always maintain the current active user intent until it is fully resolved.
+
+If you ask a clarification question, the original intent remains ACTIVE.
+
+When the user responds to a clarification, you MUST:
+
+- Combine the new information with the original request
+- Resume the same task
+- Continue the tool evaluation process
+- Complete the original objective
+
+You MUST NOT:
+- Treat clarification answers as new unrelated requests
+- Drop the original task
+- Change subject unexpectedly
+
+Clarifications are part of the same execution chain.
+
+
+3. NO HISTORICAL ASSUMPTIONS FOR DYNAMIC DATA
+
+If the user asks something that:
+
+- may change over time
+- depends on system state
+- depends on filesystem
+- depends on external APIs
+- was previously asked in the conversation
+
+You MUST NOT reuse previous outputs as final truth.
+
+You MUST:
+- Re-evaluate available tools
+- Re-execute relevant tools
+- Provide a fresh result
+
+Repeated queries require fresh verification.
+
+
+4. HISTORY IS CONTEXT, NOT SOURCE OF TRUTH
+
+Conversation history provides context, not verified data.
+
+Never assume:
+- System state
+- File contents
+- Database values
+- API responses
+
+based only on previous messages.
+
+
+5. TASK RESOLUTION LOOP
+
+You must operate in this loop:
+
+- Identify intent
+- Determine missing information (if any)
+- Ask clarification ONLY if necessary
+- When clarification is received, resume original task
+- Evaluate tools
+- Execute tools if applicable
+- Deliver verified answer
+
+Do not break this loop.
+
+
+6. TOOL PRIORITY OVER LANGUAGE GUESSING
+
+If a tool can compute, fetch, inspect, or verify something, prefer tool usage.
+
+Never hallucinate values retrievable via tools.
+
+
+7. FINAL ANSWER POLICY
+
+Provide a natural language answer only if:
+
+- No tool is relevant
+- Tools are unavailable
+- The request is purely conceptual
+
+Otherwise, use tools first.
+
+--------------------------------------------------
+
+You are a deterministic orchestration layer.
+You do not drift.
+You do not abandon tasks.
+You do not speculate when verification is possible.
+
+You maintain intent until resolution.
+
+      `);
+            // Load existing history from database
+            const previousMessages = await this.history.getMessages();
+            const messages = [
+                systemMessage,
+                ...previousMessages,
+                userMessage
+            ];
+            const response = await this.provider.invoke({ messages });
+            // Identify new messages generated during the interaction
+            // The `messages` array passed to invoke had length `messages.length`
+            // The `response.messages` contains the full state.
+            // New messages start after the inputs.
+            const startNewMessagesIndex = messages.length;
+            const newGeneratedMessages = response.messages.slice(startNewMessagesIndex);
+            // Persist User Message first
+            await this.history.addMessage(userMessage);
+            // Persist all new intermediate tool calls and responses
+            for (const msg of newGeneratedMessages) {
+                // Inject provider/model metadata search interactors
+                msg.provider_metadata = {
+                    provider: this.config.llm.provider,
+                    model: this.config.llm.model
+                };
+                await this.history.addMessage(msg);
+            }
+            this.display.log('Response generated.', { source: 'Oracle' });
+            const lastMessage = response.messages[response.messages.length - 1];
+            return (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
+        }
+        catch (err) {
+            throw new ProviderError(this.config.llm.provider, err, "Chat request failed");
+        }
+    }
+    async getHistory() {
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        return await this.history.getMessages();
+    }
+    async clearMemory() {
+        if (!this.history) {
+            throw new Error("Message history not initialized. Call initialize() first.");
+        }
+        await this.history.clear();
+    }
+}

package/dist/runtime/providers/factory.js

@@ -14,15 +14,15 @@ export class ProviderFactory {
         const toolMonitoringMiddleware = createMiddleware({
             name: "ToolMonitoringMiddleware",
             wrapToolCall: (request, handler) => {
-                display.log(`Executing tool: ${request.toolCall.name}`, { level: "warning", source: 'ToolCall' });
-                display.log(`Arguments: ${JSON.stringify(request.toolCall.args)}`, { level: "info", source: 'ToolCall' });
+                display.log(`Executing tool: ${request.toolCall.name}`, { level: "warning", source: 'ConstructLoad' });
+                display.log(`Arguments: ${JSON.stringify(request.toolCall.args)}`, { level: "info", source: 'ConstructLoad' });
                 try {
                     const result = handler(request);
-                    display.log("Tool completed successfully", { level: "info", source: 'ToolCall' });
+                    display.log("Tool completed successfully", { level: "info", source: 'ConstructLoad' });
                     return result;
                 }
                 catch (e) {
-                    display.log(`Tool failed: ${e}`, { level: "error", source: 'ToolCall' });
+                    display.log(`Tool failed: ${e}`, { level: "error", source: 'ConstructLoad' });
                     throw e;
                 }
             },

package/dist/runtime/scaffold.js

@@ -4,6 +4,7 @@ import { ConfigManager } from '../config/manager.js';
 import { DEFAULT_MCP_TEMPLATE } from '../types/mcp.js';
 import chalk from 'chalk';
 import ora from 'ora';
+import { migrateConfigFile } from './migration.js';
 export async function scaffold() {
     const spinner = ora('Ensuring Morpheus environment...').start();
     try {
@@ -15,6 +16,8 @@ export async function scaffold() {
             fs.ensureDir(PATHS.cache),
             fs.ensureDir(PATHS.commands),
         ]);
+        // Migrate config.yaml -> zaion.yaml if needed
+        await migrateConfigFile();
         // Create config if not exists
         const configManager = ConfigManager.getInstance();
         if (!(await fs.pathExists(PATHS.config))) {

package/dist/runtime/telephonist.js

@@ -0,0 +1,55 @@
+import { GoogleGenAI } from '@google/genai';
+export class Telephonist {
+    async transcribe(filePath, mimeType, apiKey) {
+        try {
+            const ai = new GoogleGenAI({ apiKey });
+            // Upload the file
+            const uploadResult = await ai.files.upload({
+                file: filePath,
+                config: { mimeType }
+            });
+            // Generate content (transcription)
+            // using gemini-1.5-flash as it is fast and supports audio
+            const response = await ai.models.generateContent({
+                model: 'gemini-2.5-flash-lite',
+                contents: [
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                fileData: {
+                                    fileUri: uploadResult.uri,
+                                    mimeType: uploadResult.mimeType
+                                }
+                            },
+                            { text: "Transcribe this audio message accurately. Return only the transcribed text without any additional commentary." }
+                        ]
+                    }
+                ]
+            });
+            // The new SDK returns text directly on the response object
+            const text = response.text;
+            if (!text) {
+                throw new Error('No transcription generated');
+            }
+            // Extract usage metadata
+            const usage = response.usageMetadata;
+            const usageMetadata = {
+                input_tokens: usage?.promptTokenCount ?? 0,
+                output_tokens: usage?.candidatesTokenCount ?? 0,
+                total_tokens: usage?.totalTokenCount ?? 0,
+                input_token_details: {
+                    cache_read: usage?.cachedContentTokenCount ?? 0
+                }
+            };
+            return { text, usage: usageMetadata };
+        }
+        catch (error) {
+            // Wrap error for clarity
+            if (error instanceof Error) {
+                throw new Error(`Audio transcription failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+}

package/dist/runtime/tools/__tests__/construtor.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Construtor } from '../factory.js';
+import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+vi.mock("@langchain/mcp-adapters", () => {
+    return {
+        MultiServerMCPClient: vi.fn(),
+    };
+});
+vi.mock("../../display.js", () => ({
+    DisplayManager: {
+        getInstance: () => ({
+            log: vi.fn(),
+        })
+    }
+}));
+describe('Construtor', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should create tools successfully', async () => {
+        const mockGetTools = vi.fn().mockResolvedValue(['tool1', 'tool2']);
+        // Mock the constructor and getTools method
+        MultiServerMCPClient.mockImplementation(function () {
+            return {
+                getTools: mockGetTools
+            };
+        });
+        const tools = await Construtor.create();
+        expect(MultiServerMCPClient).toHaveBeenCalled();
+        expect(mockGetTools).toHaveBeenCalled();
+        expect(tools).toEqual(['tool1', 'tool2']);
+    });
+    it('should return empty array on failure', async () => {
+        MultiServerMCPClient.mockImplementation(function () {
+            return {
+                getTools: vi.fn().mockRejectedValue(new Error('MCP Failed'))
+            };
+        });
+        const tools = await Construtor.create();
+        expect(tools).toEqual([]);
+    });
+});

package/dist/runtime/tools/factory.js

@@ -29,7 +29,7 @@ function sanitizeSchema(obj) {
  * Creates a proxy that intercepts schema access and sanitizes the output.
  */
 function wrapToolWithSanitizedSchema(tool) {
-    display.log('Tool loaded: - ' + tool.name, { source: 'ToolsFactory' });
+    display.log('Tool loaded: - ' + tool.name, { source: 'Construtor' });
     // The MCP tools have a schema property that returns JSON Schema
     // We need to intercept and sanitize it
     const originalSchema = tool.schema;
@@ -40,13 +40,13 @@ function wrapToolWithSanitizedSchema(tool) {
     }
     return tool;
 }
-export class ToolsFactory {
+export class Construtor {
     static async create() {
         const display = DisplayManager.getInstance();
         const mcpServers = await loadMCPConfig();
         const serverCount = Object.keys(mcpServers).length;
         if (serverCount === 0) {
-            display.log('No MCP servers configured in mcps.json', { level: 'info', source: 'ToolsFactory' });
+            display.log('No MCP servers configured in mcps.json', { level: 'info', source: 'Construtor' });
             return [];
         }
         const client = new MultiServerMCPClient({
@@ -67,11 +67,11 @@ export class ToolsFactory {
             const tools = await client.getTools();
             // Sanitize tool schemas to remove fields not supported by Gemini
             const sanitizedTools = tools.map(tool => wrapToolWithSanitizedSchema(tool));
-            display.log(`Loaded ${sanitizedTools.length} MCP tools (schemas sanitized for Gemini compatibility)`, { level: 'info', source: 'ToolsFactory' });
+            display.log(`Loaded ${sanitizedTools.length} MCP tools (schemas sanitized for Gemini compatibility)`, { level: 'info', source: 'Construtor' });
             return sanitizedTools;
         }
         catch (error) {
-            display.log(`Failed to initialize MCP tools: ${error}`, { level: 'warning', source: 'ToolsFactory' });
+            display.log(`Failed to initialize MCP tools: ${error}`, { level: 'warning', source: 'Construtor' });
             return []; // Return empty tools on failure to allow agent to start
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Morpheus CLI Agent",
   "bin": {
     "morpheus": "./bin/morpheus.js"