morpheus-cli 0.1.9 → 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'
+        });
+    }
+}