morpheus-cli 0.9.12 → 0.9.20

package/dist/runtime/subagents/registry.js

@@ -0,0 +1,134 @@
+import { DisplayManager } from "../display.js";
+/**
+ * System-level agents that are not subagents but need display metadata for audit/UI.
+ */
+export const SYSTEM_AGENTS = [
+    {
+        agentKey: 'oracle', auditAgent: 'oracle', label: 'Oracle',
+        delegateToolName: '', emoji: '🔮', color: 'blue',
+        description: 'Root orchestrator',
+        colorClass: 'text-blue-600 dark:text-blue-400',
+        bgClass: 'bg-blue-50 dark:bg-blue-900/10',
+        badgeClass: 'bg-blue-100 text-blue-700 dark:bg-blue-900/40 dark:text-blue-300',
+    },
+    {
+        agentKey: 'chronos', auditAgent: 'chronos', label: 'Chronos',
+        delegateToolName: '', emoji: '⏰', color: 'orange',
+        description: 'Temporal scheduler',
+        colorClass: 'text-orange-600 dark:text-orange-400',
+        bgClass: 'bg-orange-50 dark:bg-orange-900/10',
+        badgeClass: 'bg-orange-100 text-orange-700 dark:bg-orange-900/40 dark:text-orange-300',
+    },
+    {
+        agentKey: 'sati', auditAgent: 'sati', label: 'Sati',
+        delegateToolName: '', emoji: '🧠', color: 'emerald',
+        description: 'Long-term memory',
+        colorClass: 'text-emerald-600 dark:text-emerald-400',
+        bgClass: 'bg-emerald-50 dark:bg-emerald-900/10',
+        badgeClass: 'bg-emerald-100 text-emerald-700 dark:bg-emerald-900/40 dark:text-emerald-300',
+    },
+    {
+        agentKey: 'telephonist', auditAgent: 'telephonist', label: 'Telephonist',
+        delegateToolName: '', emoji: '📞', color: 'rose',
+        description: 'Audio transcription',
+        colorClass: 'text-rose-600 dark:text-rose-400',
+        bgClass: 'bg-rose-50 dark:bg-rose-900/10',
+        badgeClass: 'bg-rose-100 text-rose-700 dark:bg-rose-900/40 dark:text-rose-300',
+    },
+];
+/**
+ * Central registry for all subagents. Static singleton following ChannelRegistry pattern.
+ */
+export class SubagentRegistry {
+    static agents = new Map();
+    static display = DisplayManager.getInstance();
+    static register(reg) {
+        SubagentRegistry.agents.set(reg.agentKey, reg);
+        SubagentRegistry.display.log(`Subagent registered: ${reg.label} (${reg.agentKey})`, { source: 'SubagentRegistry', level: 'info' });
+    }
+    static get(agentKey) {
+        return SubagentRegistry.agents.get(agentKey);
+    }
+    static getAll() {
+        return [...SubagentRegistry.agents.values()];
+    }
+    static getByToolName(toolName) {
+        for (const reg of SubagentRegistry.agents.values()) {
+            if (reg.delegateToolName === toolName)
+                return reg;
+        }
+        return undefined;
+    }
+    /** Returns the set of all delegation tool names (replaces ORACLE_DELEGATION_TOOLS). */
+    static getDelegationToolNames() {
+        const names = new Set();
+        for (const reg of SubagentRegistry.agents.values()) {
+            if (reg.delegateToolName)
+                names.add(reg.delegateToolName);
+        }
+        return names;
+    }
+    /** Returns all delegation tools for Oracle's coreTools array. */
+    static getDelegationTools() {
+        return SubagentRegistry.getAll().map(reg => reg.instance.createDelegateTool());
+    }
+    /** Sets session ID on all registered subagents that support it. */
+    static setAllSessionIds(sessionId) {
+        for (const reg of SubagentRegistry.agents.values()) {
+            reg.setSessionId?.(sessionId);
+        }
+    }
+    /** Refreshes dynamic descriptions on all subagents that support it. */
+    static async refreshAllCatalogs() {
+        const promises = [];
+        for (const reg of SubagentRegistry.agents.values()) {
+            if (reg.hasDynamicDescription && reg.refreshCatalog) {
+                promises.push(reg.refreshCatalog().catch(() => { }));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /** Executes a task by routing to the correct subagent (replaces worker switch/case). */
+    static async executeTask(task) {
+        const reg = SubagentRegistry.agents.get(task.agent);
+        if (!reg) {
+            throw new Error(`Unknown task agent: ${task.agent}`);
+        }
+        if (reg.executeTask) {
+            return reg.executeTask(task);
+        }
+        return reg.instance.execute(task.input, task.context ?? undefined, task.session_id, {
+            origin_channel: task.origin_channel,
+            session_id: task.session_id,
+            origin_message_id: task.origin_message_id ?? undefined,
+            origin_user_id: task.origin_user_id ?? undefined,
+        });
+    }
+    /** Maps task agent key to audit agent name (e.g. 'trinit' -> 'trinity'). */
+    static resolveAuditAgent(taskAgent) {
+        const reg = SubagentRegistry.agents.get(taskAgent);
+        return (reg?.auditAgent ?? taskAgent);
+    }
+    /** Returns display metadata for all agents (subagents + system agents). */
+    static getDisplayMetadata() {
+        const subagents = SubagentRegistry.getAll().map(reg => ({
+            agentKey: reg.agentKey,
+            auditAgent: reg.auditAgent,
+            label: reg.label,
+            delegateToolName: reg.delegateToolName,
+            emoji: reg.emoji,
+            color: reg.color,
+            description: reg.description,
+            colorClass: reg.colorClass,
+            bgClass: reg.bgClass,
+            badgeClass: reg.badgeClass,
+        }));
+        return [...SYSTEM_AGENTS, ...subagents];
+    }
+    /** Reloads all registered subagents. */
+    static async reloadAll() {
+        for (const reg of SubagentRegistry.agents.values()) {
+            await reg.instance.reload();
+        }
+    }
+}

package/dist/runtime/{trinity.js → subagents/trinity/trinity.js}

@@ -1,14 +1,15 @@
 import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
 import { tool } from "@langchain/core/tools";
 import { z } from "zod";
-import { ConfigManager } from "../config/manager.js";
-import { ProviderFactory } from "./providers/factory.js";
-import { ProviderError } from "./errors.js";
-import { DisplayManager } from "./display.js";
-import { DatabaseRegistry } from "./memory/trinity-db.js";
-import { testConnection, introspectSchema, executeQuery } from "./trinity-connector.js";
-import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./subagent-utils.js";
-import { buildDelegationTool } from "./tools/delegation-utils.js";
+import { ConfigManager } from "../../../config/manager.js";
+import { ServiceContainer, SERVICE_KEYS } from "../../container.js";
+import { ProviderError } from "../../errors.js";
+import { DisplayManager } from "../../display.js";
+import { DatabaseRegistry } from "../../memory/trinity-db.js";
+import { testConnection, introspectSchema, executeQuery } from "./connector.js";
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "../utils.js";
+import { buildDelegationTool } from "../../tools/delegation-utils.js";
+import { SubagentRegistry } from "../registry.js";
 const TRINITY_BASE_DESCRIPTION = `Delegate a database task to Trinity, the specialized database subagent, asynchronously.
 
 This tool enqueues a background task and returns an acknowledgement with task id.
@@ -52,6 +53,19 @@ export class Trinity {
     static getInstance(config) {
         if (!Trinity.instance) {
             Trinity.instance = new Trinity(config);
+            SubagentRegistry.register({
+                agentKey: 'trinit', auditAgent: 'trinity', label: 'Trinity',
+                delegateToolName: 'trinity_delegate', emoji: '👩‍💻', color: 'teal',
+                description: 'Database specialist',
+                colorClass: 'text-teal-600 dark:text-teal-400',
+                bgClass: 'bg-teal-50 dark:bg-teal-900/10',
+                badgeClass: 'bg-teal-100 text-teal-700 dark:bg-teal-900/40 dark:text-teal-300',
+                instance: Trinity.instance,
+                hasDynamicDescription: true,
+                isMultiInstance: false,
+                setSessionId: (id) => Trinity.setSessionId(id),
+                refreshCatalog: () => Trinity.refreshDelegateCatalog(),
+            });
         }
         return Trinity.instance;
     }
@@ -190,7 +204,7 @@ export class Trinity {
         const tools = this.buildTrinityTools();
         this.display.log(`Trinity initialized with ${tools.length} tools (personality: ${personality}).`, { source: 'Trinity' });
         try {
-            this.agent = await ProviderFactory.createBare(trinityConfig, tools);
+            this.agent = await ServiceContainer.get(SERVICE_KEYS.providerFactory).createBare(trinityConfig, tools);
         }
         catch (err) {
             throw new ProviderError(trinityConfig.provider, err, 'Trinity subagent initialization failed');

package/dist/runtime/{subagent-utils.js → subagents/utils.js}

@@ -1,6 +1,6 @@
 import { AIMessage, ToolMessage } from "@langchain/core/messages";
-import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
-import { AuditRepository } from "./audit/repository.js";
+import { SQLiteChatMessageHistory } from "../memory/sqlite.js";
+import { AuditRepository } from "../audit/repository.js";
 /** Extract token usage from a LangChain message using 4-fallback chain. */
 export function extractRawUsage(lastMessage) {
     return lastMessage.usage_metadata

package/dist/runtime/tasks/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 { randomUUID } from 'crypto';
+import { PATHS } from '../../config/paths.js';
 export class TaskRepository {
     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/tasks/worker.js

@@ -1,10 +1,6 @@
 import { randomUUID } from 'crypto';
 import { DisplayManager } from '../display.js';
-import { Apoc } from '../apoc.js';
-import { Neo } from '../neo.js';
-import { Trinity } from '../trinity.js';
-import { Link } from '../link.js';
-import { SmithDelegator } from '../smiths/delegator.js';
+import { SubagentRegistry } from '../subagents/registry.js';
 import { TaskRepository } from './repository.js';
 import { AuditRepository } from '../audit/repository.js';
 export class TaskWorker {
@@ -52,77 +48,17 @@ export class TaskWorker {
     }
     async executeTask(task) {
         const audit = AuditRepository.getInstance();
+        const auditAgent = SubagentRegistry.resolveAuditAgent(task.agent);
         audit.insert({
             session_id: task.session_id,
             task_id: task.id,
             event_type: 'task_created',
-            agent: task.agent === 'trinit' ? 'trinity' : task.agent,
+            agent: auditAgent,
             status: 'success',
             metadata: { agent: task.agent, input_preview: task.input.slice(0, 200) },
         });
         try {
-            let result;
-            switch (task.agent) {
-                case 'apoc': {
-                    const apoc = Apoc.getInstance();
-                    result = await apoc.execute(task.input, task.context ?? undefined, task.session_id, {
-                        origin_channel: task.origin_channel,
-                        session_id: task.session_id,
-                        origin_message_id: task.origin_message_id ?? undefined,
-                        origin_user_id: task.origin_user_id ?? undefined,
-                    });
-                    break;
-                }
-                case 'neo': {
-                    const neo = Neo.getInstance();
-                    result = await neo.execute(task.input, task.context ?? undefined, task.session_id, {
-                        origin_channel: task.origin_channel,
-                        session_id: task.session_id,
-                        origin_message_id: task.origin_message_id ?? undefined,
-                        origin_user_id: task.origin_user_id ?? undefined,
-                    });
-                    break;
-                }
-                case 'trinit': {
-                    const trinity = Trinity.getInstance();
-                    result = await trinity.execute(task.input, task.context ?? undefined, task.session_id, {
-                        origin_channel: task.origin_channel,
-                        session_id: task.session_id,
-                        origin_message_id: task.origin_message_id ?? undefined,
-                        origin_user_id: task.origin_user_id ?? undefined,
-                    });
-                    break;
-                }
-                case 'smith': {
-                    // Parse smith name from context JSON
-                    let smithName = 'unknown';
-                    if (task.context) {
-                        try {
-                            const parsed = JSON.parse(task.context);
-                            smithName = parsed.smith_name || parsed.smith || 'unknown';
-                        }
-                        catch {
-                            smithName = task.context;
-                        }
-                    }
-                    const delegator = SmithDelegator.getInstance();
-                    result = await delegator.delegate(smithName, task.input, task.context ?? undefined);
-                    break;
-                }
-                case 'link': {
-                    const link = Link.getInstance();
-                    result = await link.execute(task.input, task.context ?? undefined, task.session_id, {
-                        origin_channel: task.origin_channel,
-                        session_id: task.session_id,
-                        origin_message_id: task.origin_message_id ?? undefined,
-                        origin_user_id: task.origin_user_id ?? undefined,
-                    });
-                    break;
-                }
-                default: {
-                    throw new Error(`Unknown task agent: ${task.agent}`);
-                }
-            }
+            const result = await SubagentRegistry.executeTask(task);
             this.repository.markCompleted(task.id, result.output, result.usage ? {
                 provider: result.usage.provider,
                 model: result.usage.model,
@@ -131,7 +67,7 @@ export class TaskWorker {
                 durationMs: result.usage.durationMs,
                 stepCount: result.usage.stepCount,
             } : undefined);
-            const agentName = (task.agent === 'trinit' ? 'trinity' : task.agent);
+            const agentName = auditAgent;
             // Emit task_completed audit event
             audit.insert({
                 session_id: task.session_id,
@@ -175,7 +111,7 @@ export class TaskWorker {
                 session_id: task.session_id,
                 task_id: task.id,
                 event_type: 'task_completed',
-                agent: (task.agent === 'trinit' ? 'trinity' : task.agent),
+                agent: auditAgent,
                 status: 'error',
                 metadata: { error: errorMessage },
             });

package/dist/runtime/telephonist.js

@@ -2,6 +2,9 @@ import { GoogleGenAI } from '@google/genai';
 import OpenAI from 'openai';
 import { OpenRouter } from '@openrouter/sdk';
 import fs from 'fs';
+import fsExtra from 'fs-extra';
+import path from 'path';
+import os from 'os';
 import { parseFile } from 'music-metadata';
 /**
  * Returns the actual audio duration in seconds by parsing the file header.
@@ -25,6 +28,7 @@ async function getAudioDurationSeconds(filePath) {
         return 0;
     }
 }
+export const TTS_MAX_CHARS = 4096;
 class GeminiTelephonist {
     model;
     constructor(model) {
@@ -187,6 +191,162 @@ export function createTelephonist(config) {
             throw new Error(`Unsupported audio provider: '${config.provider}'. Supported: google, openai, openrouter, ollama.`);
     }
 }
+// ─── TTS Implementations ─────────────────────────────────────────────────────
+function truncateForTts(text) {
+    if (text.length <= TTS_MAX_CHARS)
+        return text;
+    console.warn(`[Telephonist] TTS input truncated from ${text.length} to ${TTS_MAX_CHARS} chars.`);
+    return text.slice(0, TTS_MAX_CHARS);
+}
+function mimeTypeToExt(mimeType) {
+    if (mimeType.includes('ogg'))
+        return '.ogg';
+    if (mimeType.includes('mp3') || mimeType.includes('mpeg'))
+        return '.mp3';
+    if (mimeType.includes('wav'))
+        return '.wav';
+    if (mimeType.includes('aac'))
+        return '.aac';
+    return '.audio';
+}
+async function writeTempAudio(buffer, ext) {
+    const filePath = path.join(os.tmpdir(), `morpheus-tts-${Date.now()}${ext}`);
+    await fsExtra.writeFile(filePath, buffer);
+    return filePath;
+}
+/**
+ * Wraps raw PCM data in a WAV container header.
+ * Gemini TTS returns audio/pcm at 24000Hz, 16-bit, mono.
+ */
+function pcmToWav(pcmBuffer, sampleRate = 24000, channels = 1, bitDepth = 16) {
+    const header = Buffer.alloc(44);
+    const dataSize = pcmBuffer.length;
+    const byteRate = sampleRate * channels * (bitDepth / 8);
+    const blockAlign = channels * (bitDepth / 8);
+    header.write('RIFF', 0);
+    header.writeUInt32LE(36 + dataSize, 4);
+    header.write('WAVE', 8);
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16); // PCM chunk size
+    header.writeUInt16LE(1, 20); // PCM format
+    header.writeUInt16LE(channels, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(bitDepth, 34);
+    header.write('data', 36);
+    header.writeUInt32LE(dataSize, 40);
+    return Buffer.concat([header, pcmBuffer]);
+}
+class OpenAITtsTelephonist {
+    model;
+    defaultVoice;
+    constructor(model, defaultVoice) {
+        this.model = model;
+        this.defaultVoice = defaultVoice;
+    }
+    async transcribe() {
+        throw new Error('OpenAITtsTelephonist does not support transcription.');
+    }
+    async synthesize(text, apiKey, voice, stylePrompt) {
+        const client = new OpenAI({ apiKey });
+        const raw = stylePrompt ? `${stylePrompt}: ${text}` : text;
+        const input = truncateForTts(raw);
+        const response = await client.audio.speech.create({
+            model: this.model,
+            voice: (voice || this.defaultVoice),
+            input,
+            response_format: 'mp3',
+        });
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const filePath = await writeTempAudio(buffer, '.mp3');
+        return {
+            filePath,
+            mimeType: 'audio/mpeg',
+            usage: {
+                input_tokens: 0,
+                output_tokens: 0,
+                total_tokens: 0,
+                audio_duration_seconds: 0,
+            },
+        };
+    }
+}
+class GeminiTtsTelephonist {
+    model;
+    defaultVoice;
+    constructor(model, defaultVoice) {
+        this.model = model;
+        this.defaultVoice = defaultVoice;
+    }
+    async transcribe() {
+        throw new Error('GeminiTtsTelephonist does not support transcription.');
+    }
+    async synthesize(text, apiKey, voice, stylePrompt) {
+        const ai = new GoogleGenAI({ apiKey });
+        const raw = stylePrompt ? `${stylePrompt}: ${text}` : text;
+        const input = truncateForTts(raw);
+        const response = await ai.models.generateContent({
+            model: this.model,
+            contents: [{ role: 'user', parts: [{ text: input }] }],
+            config: {
+                responseModalities: ['AUDIO'],
+                speechConfig: {
+                    voiceConfig: {
+                        prebuiltVoiceConfig: { voiceName: voice || this.defaultVoice },
+                    },
+                },
+            },
+        });
+        const audioPart = response.candidates?.[0]?.content?.parts?.find((p) => p.inlineData?.mimeType?.startsWith('audio/'));
+        if (!audioPart?.inlineData?.data) {
+            throw new Error('Gemini TTS: no audio data in response');
+        }
+        const rawMimeType = audioPart.inlineData.mimeType ?? 'audio/pcm';
+        const rawBuffer = Buffer.from(audioPart.inlineData.data, 'base64');
+        let mimeType = rawMimeType;
+        let buffer;
+        // Gemini returns raw PCM — wrap it in a WAV container
+        if (rawMimeType.includes('pcm') || rawMimeType.includes('l16')) {
+            // Parse sample rate from mimeType params e.g. "audio/pcm;rate=24000"
+            const rateMatch = rawMimeType.match(/rate=(\d+)/i);
+            const sampleRate = rateMatch ? parseInt(rateMatch[1], 10) : 24000;
+            buffer = pcmToWav(rawBuffer, sampleRate);
+            mimeType = 'audio/wav';
+        }
+        else {
+            buffer = rawBuffer;
+        }
+        const ext = mimeTypeToExt(mimeType);
+        const filePath = await writeTempAudio(buffer, ext);
+        const usage = response.usageMetadata;
+        return {
+            filePath,
+            mimeType,
+            usage: {
+                input_tokens: usage?.promptTokenCount ?? 0,
+                output_tokens: usage?.candidatesTokenCount ?? 0,
+                total_tokens: usage?.totalTokenCount ?? 0,
+                audio_duration_seconds: 0,
+            },
+        };
+    }
+}
+/**
+ * Factory that creates an ITelephonist with TTS (synthesize) support.
+ * Supports providers: openai, google.
+ */
+export function createTtsTelephonist(config) {
+    switch (config.provider) {
+        case 'openai':
+            return new OpenAITtsTelephonist(config.model, config.voice);
+        case 'google':
+            return new GeminiTtsTelephonist(config.model, config.voice);
+        default:
+            throw new Error(`Unsupported TTS provider: '${config.provider}'. Supported: openai, google.`);
+    }
+}
+// ─── Legacy export for backward compatibility ─────────────────────────────────
 // Legacy export for backward compatibility
 export class Telephonist {
     delegate;

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

@@ -40,6 +40,7 @@ export const ChronosScheduleTool = tool(async ({ prompt, schedule_type, schedule
             cron_normalized: parsed.cron_normalized,
             created_by: 'oracle',
             notify_channels: channels,
+            origin_session_id: TaskRequestContext.get()?.session_id,
         });
         return JSON.stringify({
             success: true,

package/dist/runtime/tools/delegation-utils.js

@@ -1,11 +1,9 @@
 import { tool } from "@langchain/core/tools";
 import { z } from "zod";
-import { TaskRepository } from "../tasks/repository.js";
 import { TaskRequestContext } from "../tasks/context.js";
 import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
 import { DisplayManager } from "../display.js";
-import { ChannelRegistry } from "../../channels/registry.js";
-import { AuditRepository } from "../audit/repository.js";
+import { ServiceContainer, SERVICE_KEYS } from "../container.js";
 /**
  * Factory that builds a delegation StructuredTool for Apoc/Neo/Trinity.
  * Handles: composite guard, sync branch (notify→execute→audit→increment),
@@ -33,7 +31,8 @@ export function buildDelegationTool(opts) {
                 const ctx = TaskRequestContext.get();
                 const sessionId = ctx?.session_id ?? "default";
                 if (ctx?.origin_channel && ctx.origin_user_id && ctx.origin_channel !== 'api' && ctx.origin_channel !== 'ui') {
-                    ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, notifyText)
+                    ServiceContainer.get(SERVICE_KEYS.notifier)
+                        .sendToUser(ctx.origin_channel, ctx.origin_user_id, notifyText)
                         .catch(() => { });
                 }
                 try {
@@ -41,7 +40,7 @@ export function buildDelegationTool(opts) {
                     TaskRequestContext.incrementSyncDelegation();
                     display.log(`${agentLabel} sync execution completed.`, { source, level: "info" });
                     if (result.usage) {
-                        AuditRepository.getInstance().insert({
+                        ServiceContainer.get(SERVICE_KEYS.auditEmitter).emit({
                             session_id: sessionId,
                             event_type: 'llm_call',
                             agent: auditAgent,
@@ -76,8 +75,7 @@ export function buildDelegationTool(opts) {
                 return "Delegation limit reached for this user turn. Split the request or wait for current tasks.";
             }
             const ctx = TaskRequestContext.get();
-            const repository = TaskRepository.getInstance();
-            const created = repository.createTask({
+            const created = ServiceContainer.get(SERVICE_KEYS.taskEnqueuer).enqueue({
                 agent: agentKey,
                 input: task,
                 context: context ?? null,

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

@@ -2,14 +2,13 @@ import { tool } from "@langchain/core/tools";
 import { z } from "zod";
 import { ConfigManager } from "../../config/manager.js";
 import { promises as fsPromises } from "fs";
-import path from "path";
-import { homedir } from "os";
 import Database from "better-sqlite3";
+import { PATHS } from "../../config/paths.js";
 import { TaskRepository } from "../tasks/repository.js";
 import { TaskRequestContext } from "../tasks/context.js";
 import { isEnvVarSet } from "../../config/precedence.js";
 // ─── Shared ───────────────────────────────────────────────────────────────────
-const shortMemoryDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+const shortMemoryDbPath = PATHS.shortMemoryDb;
 /**
  * Map of config paths to their corresponding environment variable names.
  * Used to check if a config field is being overridden by an env var.
@@ -145,7 +144,7 @@ export const DiagnosticTool = tool(async () => {
     try {
         const timestamp = new Date().toISOString();
         const components = {};
-        const morpheusRoot = path.join(homedir(), ".morpheus");
+        const morpheusRoot = PATHS.root;
         // Configuration
         try {
             const configManager = ConfigManager.getInstance();
@@ -198,7 +197,7 @@ export const DiagnosticTool = tool(async () => {
         }
         // Short-term memory DB
         try {
-            const dbPath = path.join(morpheusRoot, "memory", "short-memory.db");
+            const dbPath = PATHS.shortMemoryDb;
             await fsPromises.access(dbPath);
             const stat = await fsPromises.stat(dbPath);
             components.shortMemoryDb = {
@@ -216,7 +215,7 @@ export const DiagnosticTool = tool(async () => {
         }
         // Sati long-term memory DB
         try {
-            const satiDbPath = path.join(morpheusRoot, "memory", "sati-memory.db");
+            const satiDbPath = PATHS.satiDb;
             await fsPromises.access(satiDbPath);
             const stat = await fsPromises.stat(satiDbPath);
             components.satiMemoryDb = {
@@ -266,7 +265,7 @@ export const DiagnosticTool = tool(async () => {
         };
         // Logs directory
         try {
-            const logsDir = path.join(morpheusRoot, "logs");
+            const logsDir = PATHS.logs;
             await fsPromises.access(logsDir);
             components.logs = {
                 status: "healthy",
@@ -762,7 +761,7 @@ export const TrinityDbManageTool = tool(async ({ action, name, id, type, host, p
                 const db = registry.getDatabase(dbId);
                 if (!db)
                     return JSON.stringify({ error: `Database "${name}" not found` });
-                const { testConnection } = await import("../trinity-connector.js");
+                const { testConnection } = await import("../subagents/trinity/connector.js");
                 const ok = await testConnection(db);
                 return JSON.stringify({ status: ok ? "connected" : "failed", database: db.name });
             }
@@ -771,10 +770,10 @@ export const TrinityDbManageTool = tool(async ({ action, name, id, type, host, p
                 const db = registry.getDatabase(dbId);
                 if (!db)
                     return JSON.stringify({ error: `Database "${name}" not found` });
-                const { introspectSchema } = await import("../trinity-connector.js");
+                const { introspectSchema } = await import("../subagents/trinity/connector.js");
                 const schema = await introspectSchema(db);
                 registry.updateSchema(dbId, JSON.stringify(schema));
-                const { Trinity } = await import("../trinity.js");
+                const { Trinity } = await import("../subagents/trinity/trinity.js");
                 await Trinity.refreshDelegateCatalog();
                 return JSON.stringify({ success: true, message: `Schema refreshed for "${db.name}"` });
             }