morpheus-cli 0.9.13 → 0.9.22

package/dist/runtime/__tests__/telephonist-tts.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createTtsTelephonist, TTS_MAX_CHARS } from '../telephonist.js';
+// ─── createTtsTelephonist factory ─────────────────────────────────────────────
+describe('createTtsTelephonist', () => {
+    it('returns an instance with synthesize() for openai provider', () => {
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'openai',
+            model: 'tts-1',
+            voice: 'alloy',
+        });
+        expect(telephonist).toBeDefined();
+        expect(typeof telephonist.synthesize).toBe('function');
+    });
+    it('returns an instance with synthesize() for google provider', () => {
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'google',
+            model: 'gemini-2.5-flash',
+            voice: 'Kore',
+        });
+        expect(telephonist).toBeDefined();
+        expect(typeof telephonist.synthesize).toBe('function');
+    });
+    it('throws for unsupported provider', () => {
+        expect(() => createTtsTelephonist({
+            enabled: true,
+            provider: 'ollama',
+            model: 'some-model',
+            voice: 'default',
+        })).toThrow(/Unsupported TTS provider/);
+    });
+    it('does not expose transcribe() meaningfully (throws)', async () => {
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'openai',
+            model: 'tts-1',
+            voice: 'alloy',
+        });
+        await expect(telephonist.transcribe('', '', '')).rejects.toThrow();
+    });
+});
+// ─── Text truncation ──────────────────────────────────────────────────────────
+describe('TTS text truncation', () => {
+    it('TTS_MAX_CHARS constant is 4096', () => {
+        expect(TTS_MAX_CHARS).toBe(4096);
+    });
+    it('short text (under 4096 chars) passes through unchanged in OpenAI synthesize', async () => {
+        // We test the truncation logic indirectly by checking that the SDK call
+        // receives the correct (non-truncated) text. We mock the OpenAI client.
+        const mockCreate = vi.fn().mockResolvedValue({
+            arrayBuffer: async () => new ArrayBuffer(8),
+        });
+        vi.mock('openai', () => ({
+            default: vi.fn().mockImplementation(() => ({
+                audio: {
+                    speech: { create: mockCreate },
+                },
+            })),
+        }));
+        vi.mock('fs-extra', () => ({
+            default: { writeFile: vi.fn().mockResolvedValue(undefined) },
+        }));
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'openai',
+            model: 'tts-1',
+            voice: 'alloy',
+        });
+        const shortText = 'Hello world';
+        await telephonist.synthesize(shortText, 'fake-key').catch(() => { });
+        // Verify the mock was called with the short text (not truncated)
+        if (mockCreate.mock.calls.length > 0) {
+            expect(mockCreate.mock.calls[0][0].input).toBe(shortText);
+        }
+    });
+    it('long text (over 4096 chars) is truncated to 4096', () => {
+        // Test the truncation logic directly by re-creating what truncateForTts does
+        const longText = 'a'.repeat(5000);
+        const truncated = longText.slice(0, 4096);
+        expect(truncated.length).toBe(4096);
+        expect(longText.length).toBeGreaterThan(4096);
+    });
+});

package/dist/runtime/adapters/AuditRepositoryAdapter.js

@@ -0,0 +1,6 @@
+import { AuditRepository } from '../audit/repository.js';
+export class AuditRepositoryAdapter {
+    emit(event) {
+        AuditRepository.getInstance().insert(event);
+    }
+}

package/dist/runtime/adapters/ChannelNotifierAdapter.js

@@ -0,0 +1,9 @@
+import { ChannelRegistry } from '../../channels/registry.js';
+export class ChannelNotifierAdapter {
+    async sendToUser(channel, userId, text) {
+        await ChannelRegistry.sendToUser(channel, userId, text);
+    }
+    async broadcast(text) {
+        await ChannelRegistry.broadcast(text);
+    }
+}

package/dist/runtime/adapters/LangChainProviderAdapter.js

@@ -0,0 +1,9 @@
+import { ProviderFactory } from '../providers/factory.js';
+export class LangChainProviderAdapter {
+    async createBare(config, tools = []) {
+        return ProviderFactory.createBare(config, tools);
+    }
+    async create(config, tools = []) {
+        return ProviderFactory.createBare(config, tools);
+    }
+}

package/dist/runtime/adapters/SQLiteChatHistoryAdapter.js

@@ -0,0 +1,15 @@
+import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+export class SQLiteChatHistoryAdapter {
+    async getMessages(sessionId) {
+        const history = new SQLiteChatMessageHistory({ sessionId });
+        return history.getMessages();
+    }
+    async addMessage(sessionId, message) {
+        const history = new SQLiteChatMessageHistory({ sessionId });
+        await history.addMessage(message);
+    }
+    async clear(sessionId) {
+        const history = new SQLiteChatMessageHistory({ sessionId });
+        await history.clear();
+    }
+}

package/dist/runtime/adapters/SQLiteTaskEnqueuerAdapter.js

@@ -0,0 +1,6 @@
+import { TaskRepository } from '../tasks/repository.js';
+export class SQLiteTaskEnqueuerAdapter {
+    enqueue(input) {
+        return TaskRepository.getInstance().createTask(input);
+    }
+}

package/dist/runtime/adapters/index.js

@@ -0,0 +1,5 @@
+export { ChannelNotifierAdapter } from './ChannelNotifierAdapter.js';
+export { SQLiteTaskEnqueuerAdapter } from './SQLiteTaskEnqueuerAdapter.js';
+export { SQLiteChatHistoryAdapter } from './SQLiteChatHistoryAdapter.js';
+export { LangChainProviderAdapter } from './LangChainProviderAdapter.js';
+export { AuditRepositoryAdapter } from './AuditRepositoryAdapter.js';

package/dist/runtime/audit/repository.js

@@ -1,14 +1,14 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { randomUUID } from 'crypto';
 import { DisplayManager } from '../display.js';
+import { PATHS } from '../../config/paths.js';
 export class AuditRepository {
     static instance = null;
     db;
     constructor() {
-        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        const dbPath = PATHS.shortMemoryDb;
         fs.ensureDirSync(path.dirname(dbPath));
         this.db = new Database(dbPath, { timeout: 5000 });
         this.db.pragma('journal_mode = WAL');
@@ -59,6 +59,10 @@ export class AuditRepository {
             DisplayManager.getInstance().log(`AuditRepository.insert failed: ${err?.message ?? String(err)}`, { source: 'Audit', level: 'error' });
         }
     }
+    countBySession(sessionId) {
+        const row = this.db.prepare(`SELECT COUNT(*) as n FROM audit_events WHERE session_id = ?`).get(sessionId);
+        return row?.n ?? 0;
+    }
     getBySession(sessionId, opts) {
         const limit = opts?.limit ?? 500;
         const offset = opts?.offset ?? 0;

package/dist/runtime/chronos/repository.js

@@ -1,9 +1,9 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { randomUUID } from 'crypto';
 import { ConfigManager } from '../../config/manager.js';
+import { PATHS } from '../../config/paths.js';
 export class ChronosError extends Error {
     constructor(message) {
         super(message);
@@ -14,7 +14,7 @@ export class ChronosRepository {
     static instance = null;
     db;
     constructor() {
-        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        const dbPath = PATHS.shortMemoryDb;
         fs.ensureDirSync(path.dirname(dbPath));
         this.db = new Database(dbPath, { timeout: 5000 });
         this.db.pragma('journal_mode = WAL');

package/dist/runtime/container.js

@@ -0,0 +1,50 @@
+/**
+ * ServiceContainer — Composition Root
+ *
+ * Simple typed registry for application services (ports).
+ * Configured once at startup in start.ts. No DI framework magic —
+ * just a Map with type-safe get/register.
+ *
+ * Usage:
+ *   // Registration (start.ts):
+ *   ServiceContainer.register('notifier', new ChannelNotifierAdapter());
+ *
+ *   // Consumption:
+ *   const notifier = ServiceContainer.get<INotifier>('notifier');
+ */
+export class ServiceContainer {
+    static services = new Map();
+    /** Register a service under a given key. Overwrites if already registered. */
+    static register(key, service) {
+        ServiceContainer.services.set(key, service);
+    }
+    /**
+     * Retrieve a registered service.
+     * @throws if the key is not registered.
+     */
+    static get(key) {
+        const service = ServiceContainer.services.get(key);
+        if (service === undefined) {
+            throw new Error(`ServiceContainer: "${key}" is not registered. Did you call register() in start.ts?`);
+        }
+        return service;
+    }
+    /** Returns true if a service is registered under the given key. */
+    static has(key) {
+        return ServiceContainer.services.has(key);
+    }
+    /** Remove all registered services (useful in tests). */
+    static reset() {
+        ServiceContainer.services.clear();
+    }
+}
+/**
+ * Well-known service keys — use these constants to avoid typo bugs.
+ */
+export const SERVICE_KEYS = {
+    notifier: 'notifier',
+    taskEnqueuer: 'taskEnqueuer',
+    chatHistory: 'chatHistory',
+    providerFactory: 'providerFactory',
+    auditEmitter: 'auditEmitter',
+};

package/dist/runtime/display.js

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

package/dist/runtime/hot-reload.js

@@ -7,9 +7,7 @@
  */
 import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from './display.js';
-import { Apoc } from './subagents/apoc.js';
-import { Neo } from './subagents/neo.js';
-import { Trinity } from './subagents/trinity/trinity.js';
+import { SubagentRegistry } from './subagents/registry.js';
 let currentOracle = null;
 /**
  * Register the current Oracle instance for hot-reload.
@@ -44,12 +42,11 @@ export async function hotReloadConfig() {
             reinitialized.push('Oracle');
             display.log('Oracle reinitialized with new config', { source: 'HotReload', level: 'info' });
         }
-        // 3. Reset subagent singletons - they will reinitialize with new config on next use
-        Apoc.resetInstance();
-        Neo.resetInstance();
-        Trinity.resetInstance();
-        reinitialized.push('Apoc', 'Neo', 'Trinity');
-        display.log('Subagent singletons reset (will reinitialize on next use)', { source: 'HotReload', level: 'info' });
+        // 3. Reload all registered subagents via SubagentRegistry
+        await SubagentRegistry.reloadAll();
+        const agentNames = SubagentRegistry.getAll().map(r => r.label);
+        reinitialized.push(...agentNames);
+        display.log(`Subagents reloaded: ${agentNames.join(', ')}`, { source: 'HotReload', level: 'info' });
         return {
             success: true,
             reinitialized,

package/dist/runtime/memory/backfill-embeddings.js

@@ -1,9 +1,8 @@
 import Database from 'better-sqlite3';
 import { EmbeddingService } from './embedding.service.js';
-import path from 'path';
-import { homedir } from 'os';
 import loadVecExtension from './sqlite-vec.js';
-const db = new Database(path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db'));
+import { PATHS } from '../../config/paths.js';
+const db = new Database(PATHS.satiDb);
 db.pragma('journal_mode = WAL');
 // 🔥 ISSO AQUI É O QUE ESTÁ FALTANDO
 loadVecExtension(db);

package/dist/runtime/memory/sati/repository.js

@@ -1,11 +1,11 @@
 import Database from 'better-sqlite3';
-import path from 'path';
-import { homedir } from 'os';
 import fs from 'fs-extra';
+import path from 'path';
 import { randomUUID } from 'crypto';
 import loadVecExtension from '../sqlite-vec.js';
 import { DisplayManager } from '../../display.js';
 import { ConfigManager } from '../../../config/manager.js';
+import { PATHS } from '../../../config/paths.js';
 const EMBEDDING_DIM = 384;
 export class SatiRepository {
     db = null;
@@ -14,7 +14,7 @@ export class SatiRepository {
     display = DisplayManager.getInstance();
     constructor(dbPath) {
         this.dbPath =
-            dbPath || path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
+            dbPath || PATHS.satiDb;
     }
     static getInstance(dbPath) {
         if (!SatiRepository.instance) {

package/dist/runtime/memory/sqlite.js

@@ -3,7 +3,7 @@ import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/
 import Database from "better-sqlite3";
 import fs from "fs-extra";
 import * as path from "path";
-import { homedir } from "os";
+import { PATHS } from "../../config/paths.js";
 import { randomUUID } from 'crypto';
 import { DisplayManager } from "../display.js";
 export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
@@ -22,7 +22,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         this.sessionId = fields.sessionId && fields.sessionId !== '' ? fields.sessionId : '';
         this.limit = fields.limit ? fields.limit : 20;
         // Default path: ~/.morpheus/memory/short-memory.db
-        const dbPath = fields.databasePath || path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+        const dbPath = fields.databasePath || PATHS.shortMemoryDb;
         // Ensure the directory exists
         this.ensureDirectory(dbPath);
         // Initialize database with retry logic for locked databases
@@ -874,7 +874,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         const sessionText = tx(); // Executar a transação
         // Criar chunks no banco Sati — conexão aberta localmente e fechada ao fim
         if (sessionText) {
-            const dbSatiPath = path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
+            const dbSatiPath = PATHS.satiDb;
             this.ensureDirectory(dbSatiPath);
             const dbSati = new Database(dbSatiPath, { timeout: 5000 });
             dbSati.pragma('journal_mode = WAL');

package/dist/runtime/memory/trinity-db.js

@@ -1,8 +1,8 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { encrypt, decrypt, canEncrypt } from '../trinity-crypto.js';
+import { PATHS } from '../../config/paths.js';
 function safeDecrypt(value) {
     if (!value)
         return null;
@@ -39,7 +39,7 @@ export class DatabaseRegistry {
     static instance = null;
     db;
     constructor() {
-        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'trinity.db');
+        const dbPath = PATHS.trinityDb;
         fs.ensureDirSync(path.dirname(dbPath));
         this.db = new Database(dbPath, { timeout: 5000 });
         this.db.pragma('journal_mode = WAL');

package/dist/runtime/ports/IAuditEmitter.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/ports/IChatHistory.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/ports/ILLMProviderFactory.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/ports/INotifier.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/ports/ITaskEnqueuer.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/ports/index.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/providers/factory.js

@@ -1,16 +1,13 @@
-import { ChatOpenAI } from "@langchain/openai";
-import { ChatAnthropic } from "@langchain/anthropic";
-import { ChatOllama } from "@langchain/ollama";
-import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 import { ProviderError } from "../errors.js";
 import { createAgent, createMiddleware } from "langchain";
 import { DisplayManager } from "../display.js";
-import { getUsableApiKey } from "../trinity-crypto.js";
 import { ConfigManager } from "../../config/manager.js";
 import { TaskRequestContext } from "../tasks/context.js";
 import { ChannelRegistry } from "../../channels/registry.js";
+import { getStrategy, registerStrategy } from "./strategies.js";
 /** Channels that should NOT receive verbose tool notifications */
 const SILENT_CHANNELS = new Set(['api', 'ui']);
+export { registerStrategy };
 export class ProviderFactory {
     static buildMonitoringMiddleware() {
         const display = DisplayManager.getInstance();
@@ -41,44 +38,11 @@ export class ProviderFactory {
         });
     }
     static buildModel(config) {
-        const usableApiKey = getUsableApiKey(config.api_key);
-        switch (config.provider) {
-            case 'openai':
-                return new ChatOpenAI({
-                    modelName: config.model,
-                    temperature: config.temperature,
-                    apiKey: process.env.OPENAI_API_KEY || usableApiKey,
-                });
-            case 'anthropic':
-                return new ChatAnthropic({
-                    modelName: config.model,
-                    temperature: config.temperature,
-                    apiKey: process.env.ANTHROPIC_API_KEY || usableApiKey,
-                });
-            case 'openrouter':
-                return new ChatOpenAI({
-                    modelName: config.model,
-                    temperature: config.temperature,
-                    apiKey: process.env.OPENROUTER_API_KEY || usableApiKey,
-                    configuration: {
-                        baseURL: config.base_url || 'https://openrouter.ai/api/v1'
-                    }
-                });
-            case 'ollama':
-                return new ChatOllama({
-                    model: config.model,
-                    temperature: config.temperature,
-                    baseUrl: config.base_url || usableApiKey,
-                });
-            case 'gemini':
-                return new ChatGoogleGenerativeAI({
-                    model: config.model,
-                    temperature: config.temperature,
-                    apiKey: process.env.GOOGLE_API_KEY || usableApiKey
-                });
-            default:
-                throw new Error(`Unsupported provider: ${config.provider}`);
+        const strategy = getStrategy(config.provider);
+        if (!strategy) {
+            throw new Error(`Unsupported provider: ${config.provider}`);
         }
+        return strategy.build(config);
     }
     static handleProviderError(config, error) {
         let suggestion = "Check your configuration and API keys.";
@@ -114,14 +78,6 @@ export class ProviderFactory {
             ProviderFactory.handleProviderError(config, error);
         }
     }
-    static async create(config, tools = []) {
-        try {
-            const model = ProviderFactory.buildModel(config);
-            const middleware = ProviderFactory.buildMonitoringMiddleware();
-            return createAgent({ model, tools, middleware: [middleware] });
-        }
-        catch (error) {
-            ProviderFactory.handleProviderError(config, error);
-        }
-    }
+    /** Alias for createBare — both methods are identical. */
+    static create = ProviderFactory.createBare;
 }

package/dist/runtime/providers/strategies.js

@@ -0,0 +1,66 @@
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatOllama } from "@langchain/ollama";
+import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
+import { getUsableApiKey } from "../trinity-crypto.js";
+class OpenAIStrategy {
+    build(config) {
+        return new ChatOpenAI({
+            modelName: config.model,
+            temperature: config.temperature,
+            apiKey: process.env.OPENAI_API_KEY || getUsableApiKey(config.api_key),
+        });
+    }
+}
+class AnthropicStrategy {
+    build(config) {
+        return new ChatAnthropic({
+            modelName: config.model,
+            temperature: config.temperature,
+            apiKey: process.env.ANTHROPIC_API_KEY || getUsableApiKey(config.api_key),
+        });
+    }
+}
+class OpenRouterStrategy {
+    build(config) {
+        return new ChatOpenAI({
+            modelName: config.model,
+            temperature: config.temperature,
+            apiKey: process.env.OPENROUTER_API_KEY || getUsableApiKey(config.api_key),
+            configuration: {
+                baseURL: config.base_url || 'https://openrouter.ai/api/v1'
+            }
+        });
+    }
+}
+class OllamaStrategy {
+    build(config) {
+        return new ChatOllama({
+            model: config.model,
+            temperature: config.temperature,
+            baseUrl: config.base_url || getUsableApiKey(config.api_key),
+        });
+    }
+}
+class GeminiStrategy {
+    build(config) {
+        return new ChatGoogleGenerativeAI({
+            model: config.model,
+            temperature: config.temperature,
+            apiKey: process.env.GOOGLE_API_KEY || getUsableApiKey(config.api_key),
+        });
+    }
+}
+const strategies = new Map([
+    ['openai', new OpenAIStrategy()],
+    ['anthropic', new AnthropicStrategy()],
+    ['openrouter', new OpenRouterStrategy()],
+    ['ollama', new OllamaStrategy()],
+    ['gemini', new GeminiStrategy()],
+]);
+export function registerStrategy(provider, strategy) {
+    strategies.set(provider, strategy);
+}
+export function getStrategy(provider) {
+    return strategies.get(provider);
+}

package/dist/runtime/setup/repository.js

@@ -1,13 +1,13 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { ConfigManager } from '../../config/manager.js';
+import { PATHS } from '../../config/paths.js';
 export class SetupRepository {
     static instance = null;
     db;
     constructor(dbPath) {
-        const resolvedPath = dbPath ?? path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        const resolvedPath = dbPath ?? PATHS.shortMemoryDb;
         fs.ensureDirSync(path.dirname(resolvedPath));
         this.db = new Database(resolvedPath, { timeout: 5000 });
         this.db.pragma('journal_mode = WAL');

package/dist/runtime/subagents/apoc.js

@@ -1,6 +1,6 @@
 import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
 import { ConfigManager } from "../../config/manager.js";
-import { ProviderFactory } from "../providers/factory.js";
+import { ServiceContainer, SERVICE_KEYS } from "../container.js";
 import { ProviderError } from "../errors.js";
 import { DisplayManager } from "../display.js";
 import { buildDevKit } from "morpheus-devkit";
@@ -78,7 +78,7 @@ export class Apoc {
         const tools = instrumentDevKitTools(rawTools, () => Apoc.currentSessionId, () => 'apoc');
         this.display.log(`Apoc initialized with ${tools.length} DevKit tools (sandbox_dir: ${devkit.sandbox_dir}, personality: ${personality})`, { source: "Apoc" });
         try {
-            this.agent = await ProviderFactory.createBare(apocConfig, tools);
+            this.agent = await ServiceContainer.get(SERVICE_KEYS.providerFactory).createBare(apocConfig, tools);
         }
         catch (err) {
             throw new ProviderError(apocConfig.provider, err, "Apoc subagent initialization failed");

package/dist/runtime/subagents/link/link.js

@@ -4,7 +4,7 @@ import { DynamicStructuredTool } from "@langchain/core/tools";
 import { ConfigManager } from '../../../config/manager.js';
 import { LinkRepository } from './repository.js';
 import { LinkSearch } from './search.js';
-import { ProviderFactory } from '../../providers/factory.js';
+import { ServiceContainer, SERVICE_KEYS } from '../../container.js';
 import { ProviderError } from '../../errors.js';
 import { DisplayManager } from '../../display.js';
 import { TaskRequestContext } from '../../tasks/context.js';
@@ -268,7 +268,7 @@ export class Link {
         }
         this.display.log(`Link initialized with personality: ${personality}.`, { source: 'Link' });
         try {
-            this.agent = await ProviderFactory.create(linkConfig, tools);
+            this.agent = await ServiceContainer.get(SERVICE_KEYS.providerFactory).create(linkConfig, tools);
         }
         catch (err) {
             throw new ProviderError(linkConfig.provider, err, 'Link subagent initialization failed');

package/dist/runtime/subagents/link/repository.js

@@ -1,10 +1,10 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { randomUUID } from 'crypto';
 import loadVecExtension from '../../memory/sqlite-vec.js';
 import { DisplayManager } from '../../display.js';
+import { PATHS } from '../../../config/paths.js';
 // ─── Repository ──────────────────────────────────────────────────────────────
 const EMBEDDING_DIM = 384;
 export class LinkRepository {
@@ -13,7 +13,7 @@ export class LinkRepository {
     dbPath;
     display = DisplayManager.getInstance();
     constructor(dbPath) {
-        this.dbPath = dbPath || path.join(homedir(), '.morpheus', 'memory', 'link.db');
+        this.dbPath = dbPath || PATHS.linkDb;
     }
     static getInstance(dbPath) {
         if (!LinkRepository.instance) {