morpheus-cli 0.9.12 → 0.9.20

package/dist/runtime/oracle.js

@@ -5,12 +5,9 @@ import { ProviderError } from "./errors.js";
 import { DisplayManager } from "./display.js";
 import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
 import { SatiMemoryMiddleware } from "./memory/sati/index.js";
-import { Apoc } from "./apoc.js";
+import { Apoc, Neo, Trinity, Link, SubagentRegistry, emitToolAuditEvents } from "./subagents/index.js";
 import { TaskRequestContext } from "./tasks/context.js";
 import { TaskRepository } from "./tasks/repository.js";
-import { Neo } from "./neo.js";
-import { Trinity } from "./trinity.js";
-import { Link } from "./link.js";
 import { SmithDelegateTool } from "./tools/smith-tool.js";
 import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { Construtor } from "./tools/factory.js";
@@ -20,12 +17,9 @@ import { SmithRegistry } from "./smiths/registry.js";
 import { AuditRepository } from "./audit/repository.js";
 import { SetupRepository } from './setup/repository.js';
 import { buildSetupTool } from './tools/setup-tool.js';
-import { emitToolAuditEvents } from "./subagent-utils.js";
+import { SmithDelegator } from "./smiths/delegator.js";
 import { PATHS } from "../config/paths.js";
 import { writeFileSync } from "fs";
-const ORACLE_DELEGATION_TOOLS = new Set([
-    'apoc_delegate', 'neo_delegate', 'trinity_delegate', 'smith_delegate', 'link_delegate',
-]);
 export class Oracle {
     provider;
     config;
@@ -40,6 +34,48 @@ export class Oracle {
         this.config = config || ConfigManager.getInstance().get();
         this.databasePath = overrides?.databasePath;
     }
+    /**
+     * Registers Smith in the SubagentRegistry if Smiths are configured and enabled.
+     * Smith is special — it uses a standalone tool (SmithDelegateTool) and SmithDelegator
+     * rather than implementing ISubagent, so we create a minimal registration.
+     */
+    registerSmithIfEnabled() {
+        const smithsConfig = ConfigManager.getInstance().getSmithsConfig();
+        if (!smithsConfig.enabled || smithsConfig.entries.length === 0)
+            return;
+        if (SubagentRegistry.get('smith'))
+            return; // already registered
+        const delegator = SmithDelegator.getInstance();
+        SubagentRegistry.register({
+            agentKey: 'smith', auditAgent: 'smith', label: 'Smith',
+            delegateToolName: 'smith_delegate', emoji: '🕶️', color: 'gray',
+            description: 'Remote DevKit execution',
+            colorClass: 'text-gray-500 dark:text-gray-400',
+            bgClass: 'bg-gray-50 dark:bg-zinc-900',
+            badgeClass: 'bg-gray-200 text-gray-700 dark:bg-gray-700/60 dark:text-gray-300',
+            instance: {
+                initialize: async () => { },
+                execute: async (task, context) => delegator.delegate('unknown', task, context),
+                reload: async () => { },
+                createDelegateTool: () => SmithDelegateTool,
+            },
+            hasDynamicDescription: false,
+            isMultiInstance: true,
+            executeTask: async (task) => {
+                let smithName = 'unknown';
+                if (task.context) {
+                    try {
+                        const parsed = JSON.parse(task.context);
+                        smithName = parsed.smith_name || parsed.smith || 'unknown';
+                    }
+                    catch {
+                        smithName = task.context;
+                    }
+                }
+                return delegator.delegate(smithName, task.input, task.context ?? undefined);
+            },
+        });
+    }
     buildDelegationFailureResponse() {
         return "Task enqueue could not be confirmed in the database. No task was created. Please retry.";
     }
@@ -115,13 +151,16 @@ export class Oracle {
         return valid;
     }
     hasDelegationToolCall(messages) {
+        const delegationTools = SubagentRegistry.getDelegationToolNames();
+        // Also include smith_delegate which may not be in registry if smiths are disabled
+        delegationTools.add('smith_delegate');
         for (const msg of messages) {
             if (!(msg instanceof AIMessage))
                 continue;
             const toolCalls = msg.tool_calls ?? [];
             if (!Array.isArray(toolCalls))
                 continue;
-            if (toolCalls.some((tc) => tc?.name === "apoc_delegate" || tc?.name === "neo_delegate" || tc?.name === "trinity_delegate" || tc?.name === "smith_delegate" || tc?.name === "link_delegate")) {
+            if (toolCalls.some((tc) => delegationTools.has(tc?.name))) {
                 return true;
             }
         }
@@ -152,27 +191,30 @@ export class Oracle {
         // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
         // to allow for Environment Variable fallback supported by LangChain.
         try {
-            // Refresh Neo and Trinity tool catalogs so delegate descriptions contain runtime info.
-            // Fail-open: Oracle can still initialize even if catalog refresh fails.
-            await Neo.refreshDelegateCatalog().catch(() => { });
-            await Trinity.refreshDelegateCatalog().catch(() => { });
-            await Link.refreshDelegateCatalog().catch(() => { });
-            // Build tool list — conditionally include SmithDelegateTool based on config
+            // Ensure subagents are instantiated and self-registered before using the registry.
+            Apoc.getInstance();
+            Neo.getInstance();
+            Trinity.getInstance();
+            Link.getInstance();
+            // Register Smith in the registry if configured
+            this.registerSmithIfEnabled();
+            // Refresh dynamic tool catalogs so delegate descriptions contain runtime info.
+            await SubagentRegistry.refreshAllCatalogs();
             // Initialize setup repository (creates table if needed)
             SetupRepository.getInstance();
             const coreTools = [
                 buildSetupTool(),
                 TaskQueryTool,
-                Neo.getInstance().createDelegateTool(),
-                Apoc.getInstance().createDelegateTool(),
-                Trinity.getInstance().createDelegateTool(),
-                Link.getInstance().createDelegateTool(),
+                ...SubagentRegistry.getDelegationTools(),
                 createLoadSkillTool(),
                 timeVerifierTool,
                 ...chronosTools,
             ];
+            // Smith's tool is already included via SubagentRegistry.getDelegationTools()
+            // if registerSmithIfEnabled() registered it. Only add it if Smith is enabled
+            // but NOT yet in the registry (shouldn't happen, but defensive).
             const smithsConfig = ConfigManager.getInstance().getSmithsConfig();
-            if (smithsConfig.enabled && smithsConfig.entries.length > 0) {
+            if (smithsConfig.enabled && smithsConfig.entries.length > 0 && !SubagentRegistry.get('smith')) {
                 coreTools.push(SmithDelegateTool);
             }
             this.provider = await ProviderFactory.create(this.config.llm, coreTools);
@@ -225,12 +267,14 @@ export class Oracle {
                 provider: isTelephonist ? this.config.audio?.provider : this.config.llm.provider,
                 model: isTelephonist ? this.config.audio?.model : this.config.llm.model
             };
-            // Inject source metadata for automated origins (webhook, chronos)
-            if (taskContext?.origin_channel === 'webhook') {
-                userMessage.source_metadata = { source: 'webhook' };
-            }
-            else if (taskContext?.origin_channel === 'chronos') {
-                userMessage.source_metadata = { source: 'chronos' };
+            // Inject source metadata for automated origins (webhook, chronos).
+            // Prefer explicit taskContext.source (set by Chronos even when origin_channel
+            // points to a specific notification channel like 'telegram').
+            const messageSource = taskContext?.source ?? (taskContext?.origin_channel === 'webhook' ? 'webhook'
+                : taskContext?.origin_channel === 'chronos' ? 'chronos'
+                    : null);
+            if (messageSource) {
+                userMessage.source_metadata = { source: messageSource };
             }
             // Attach extra usage (e.g. from Audio) to the user message to be persisted
             if (extraUsage) {
@@ -465,10 +509,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             }
             messages.push(...previousMessages);
             messages.push(userMessage);
-            Apoc.setSessionId(currentSessionId);
-            Neo.setSessionId(currentSessionId);
-            Trinity.setSessionId(currentSessionId);
-            Link.setSessionId(currentSessionId);
+            SubagentRegistry.setAllSessionIds(currentSessionId);
             const invokeContext = {
                 origin_channel: taskContext?.origin_channel ?? "api",
                 session_id: taskContext?.session_id ?? currentSessionId ?? "default",
@@ -514,8 +555,10 @@ Use it to inform your response and tool selection (if needed), but do not assume
             // Emit tool_call audit events for Oracle's independent tool calls.
             // Delegation tools (apoc/neo/trinity/smith/skill/link) are already audited
             // inside buildDelegationTool or the task system — skip them here.
+            const delegationToolNames = SubagentRegistry.getDelegationToolNames();
+            delegationToolNames.add('smith_delegate');
             emitToolAuditEvents(newGeneratedMessages, currentSessionId ?? 'default', 'oracle', {
-                skipTools: ORACLE_DELEGATION_TOOLS,
+                skipTools: delegationToolNames,
             });
             // Inject provider/model metadata and duration into all new AI messages
             for (const msg of newGeneratedMessages) {
@@ -694,24 +737,16 @@ Use it to inform your response and tool selection (if needed), but do not assume
         }
         // Reload MCP tool cache from servers (slow path)
         await Construtor.reload();
-        await Neo.refreshDelegateCatalog().catch(() => { });
-        await Trinity.refreshDelegateCatalog().catch(() => { });
-        await Link.refreshDelegateCatalog().catch(() => { });
+        await SubagentRegistry.refreshAllCatalogs();
         this.provider = await ProviderFactory.create(this.config.llm, [
             buildSetupTool(),
             TaskQueryTool,
-            Neo.getInstance().createDelegateTool(),
-            Apoc.getInstance().createDelegateTool(),
-            Trinity.getInstance().createDelegateTool(),
-            Link.getInstance().createDelegateTool(),
+            ...SubagentRegistry.getDelegationTools(),
             createLoadSkillTool(),
             timeVerifierTool,
             ...chronosTools,
         ]);
-        await Neo.getInstance().reload();
-        await Apoc.getInstance().reload();
-        await Trinity.getInstance().reload();
-        await Link.getInstance().reload();
-        this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
+        await SubagentRegistry.reloadAll();
+        this.display.log(`Oracle and subagent tools reloaded`, { source: 'Oracle' });
     }
 }

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/ISubagent.js

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

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

@@ -1,12 +1,13 @@
 import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
-import { ConfigManager } from "../config/manager.js";
-import { ProviderFactory } from "./providers/factory.js";
-import { ProviderError } from "./errors.js";
-import { DisplayManager } from "./display.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 { buildDevKit } from "morpheus-devkit";
 import { instrumentDevKitTools } from "./devkit-instrument.js";
-import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./subagent-utils.js";
-import { buildDelegationTool } from "./tools/delegation-utils.js";
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./utils.js";
+import { buildDelegationTool } from "../tools/delegation-utils.js";
+import { SubagentRegistry } from "./registry.js";
 /**
  * Apoc is a subagent of Oracle specialized in devtools operations.
  * It receives delegated tasks from Oracle and executes them using DevKit tools
@@ -36,6 +37,18 @@ export class Apoc {
     static getInstance(config) {
         if (!Apoc.instance) {
             Apoc.instance = new Apoc(config);
+            SubagentRegistry.register({
+                agentKey: 'apoc', auditAgent: 'apoc', label: 'Apoc',
+                delegateToolName: 'apoc_delegate', emoji: '🧑‍🔬', color: 'amber',
+                description: 'Filesystem, shell & browser',
+                colorClass: 'text-amber-600 dark:text-amber-400',
+                bgClass: 'bg-amber-50 dark:bg-amber-900/10',
+                badgeClass: 'bg-amber-100 text-amber-700 dark:bg-amber-900/40 dark:text-amber-300',
+                instance: Apoc.instance,
+                hasDynamicDescription: false,
+                isMultiInstance: false,
+                setSessionId: (id) => Apoc.setSessionId(id),
+            });
         }
         return Apoc.instance;
     }
@@ -65,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/{devkit-instrument.js → subagents/devkit-instrument.js}

@@ -1,4 +1,4 @@
-import { AuditRepository } from './audit/repository.js';
+import { AuditRepository } from '../audit/repository.js';
 /**
  * Wraps a StructuredTool to record audit events on each invocation.
  * The `getSessionId` getter is called at invocation time so it reflects

package/dist/runtime/subagents/index.js

@@ -0,0 +1,12 @@
+// Re-exports for convenient external access
+export { Apoc } from './apoc.js';
+export { Neo } from './neo.js';
+export { Trinity } from './trinity/trinity.js';
+export { Link } from './link/link.js';
+export { SubagentRegistry, SYSTEM_AGENTS } from './registry.js';
+export { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from './utils.js';
+export { LinkRepository } from './link/repository.js';
+export { LinkWorker } from './link/worker.js';
+export { LinkSearch } from './link/search.js';
+export { instrumentDevKitTools } from './devkit-instrument.js';
+export { testConnection, introspectSchema, executeQuery } from './trinity/connector.js';

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

@@ -1,15 +1,16 @@
 import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
 import { z } from "zod";
 import { DynamicStructuredTool } from "@langchain/core/tools";
-import { ConfigManager } from '../config/manager.js';
-import { LinkRepository } from './link-repository.js';
-import { LinkSearch } from './link-search.js';
-import { ProviderFactory } from './providers/factory.js';
-import { ProviderError } from './errors.js';
-import { DisplayManager } from './display.js';
-import { TaskRequestContext } from './tasks/context.js';
-import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from './subagent-utils.js';
-import { buildDelegationTool } from './tools/delegation-utils.js';
+import { ConfigManager } from '../../../config/manager.js';
+import { LinkRepository } from './repository.js';
+import { LinkSearch } from './search.js';
+import { ServiceContainer, SERVICE_KEYS } from '../../container.js';
+import { ProviderError } from '../../errors.js';
+import { DisplayManager } from '../../display.js';
+import { TaskRequestContext } from '../../tasks/context.js';
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from '../utils.js';
+import { buildDelegationTool } from '../../tools/delegation-utils.js';
+import { SubagentRegistry } from '../registry.js';
 const LINK_BASE_DESCRIPTION = `Delegate to Link, the documentation specialist subagent.
 
 Link has access to indexed user documents (PDFs, Markdown, TXT, DOCX) stored in ~/.morpheus/docs.
@@ -58,6 +59,19 @@ export class Link {
                 config = ConfigManager.getInstance().get();
             }
             Link.instance = new Link(config);
+            SubagentRegistry.register({
+                agentKey: 'link', auditAgent: 'link', label: 'Link',
+                delegateToolName: 'link_delegate', emoji: '🕵️‍♂️', color: 'indigo',
+                description: 'Document search & RAG',
+                colorClass: 'text-indigo-600 dark:text-indigo-400',
+                bgClass: 'bg-indigo-50 dark:bg-indigo-900/10',
+                badgeClass: 'bg-indigo-100 text-indigo-700 dark:bg-indigo-900/40 dark:text-indigo-300',
+                instance: Link.instance,
+                hasDynamicDescription: true,
+                isMultiInstance: false,
+                setSessionId: (id) => Link.setSessionId(id),
+                refreshCatalog: () => Link.refreshDelegateCatalog(),
+            });
         }
         return Link.instance;
     }
@@ -254,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/{link-repository.js → 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 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) {

package/dist/runtime/{link-search.js → subagents/link/search.js}

@@ -1,6 +1,6 @@
-import { LinkRepository } from './link-repository.js';
-import { ConfigManager } from '../config/manager.js';
-import { EmbeddingService } from './memory/embedding.service.js';
+import { LinkRepository } from './repository.js';
+import { ConfigManager } from '../../../config/manager.js';
+import { EmbeddingService } from '../../memory/embedding.service.js';
 /**
  * LinkSearch - Hybrid search for Link documents
  *

package/dist/runtime/{link-worker.js → subagents/link/worker.js}

@@ -1,13 +1,13 @@
-import { homedir } from 'os';
-import path from 'path';
 import fs from 'fs-extra';
 import fsSync from 'fs';
-import { LinkRepository } from './link-repository.js';
-import { LinkSearch } from './link-search.js';
-import { hashFile, processDocument, isSupportedFormat } from './link-chunker.js';
-import { EmbeddingService } from './memory/embedding.service.js';
-import { ConfigManager } from '../config/manager.js';
-import { DisplayManager } from './display.js';
+import path from 'path';
+import { LinkRepository } from './repository.js';
+import { LinkSearch } from './search.js';
+import { hashFile, processDocument, isSupportedFormat } from './chunker.js';
+import { EmbeddingService } from '../../memory/embedding.service.js';
+import { ConfigManager } from '../../../config/manager.js';
+import { DisplayManager } from '../../display.js';
+import { PATHS } from '../../../config/paths.js';
 /**
  * LinkWorker - Background worker for document indexing
  *
@@ -26,7 +26,7 @@ export class LinkWorker {
     constructor() {
         this.repository = LinkRepository.getInstance();
         this.search = LinkSearch.getInstance();
-        this.docsPath = path.join(homedir(), '.morpheus', 'docs');
+        this.docsPath = PATHS.docs;
     }
     static getInstance() {
         if (!LinkWorker.instance) {

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

@@ -1,13 +1,14 @@
 import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
-import { ConfigManager } from "../config/manager.js";
-import { ProviderFactory } from "./providers/factory.js";
-import { ProviderError } from "./errors.js";
-import { DisplayManager } from "./display.js";
-import { Construtor } from "./tools/factory.js";
-import { morpheusTools } from "./tools/index.js";
-import { TaskRequestContext } from "./tasks/context.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 { Construtor } from "../tools/factory.js";
+import { morpheusTools } from "../tools/index.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./utils.js";
+import { buildDelegationTool } from "../tools/delegation-utils.js";
+import { SubagentRegistry } from "./registry.js";
 // Internal Morpheus tools get 'tool_call' event type; MCP tools get 'mcp_tool'
 const MORPHEUS_TOOL_NAMES = new Set(morpheusTools.map((t) => t.name));
 const NEO_BUILTIN_CAPABILITIES = `
@@ -61,6 +62,19 @@ export class Neo {
     static getInstance(config) {
         if (!Neo.instance) {
             Neo.instance = new Neo(config);
+            SubagentRegistry.register({
+                agentKey: 'neo', auditAgent: 'neo', label: 'Neo',
+                delegateToolName: 'neo_delegate', emoji: '🥷', color: 'violet',
+                description: 'MCP tool orchestration',
+                colorClass: 'text-violet-600 dark:text-violet-400',
+                bgClass: 'bg-violet-50 dark:bg-violet-900/10',
+                badgeClass: 'bg-purple-100 text-purple-700 dark:bg-purple-900/40 dark:text-purple-300',
+                instance: Neo.instance,
+                hasDynamicDescription: true,
+                isMultiInstance: false,
+                setSessionId: (id) => Neo.setSessionId(id),
+                refreshCatalog: () => Neo.refreshDelegateCatalog(),
+            });
         }
         return Neo.instance;
     }
@@ -87,7 +101,7 @@ export class Neo {
         }
         this.display.log(`Neo initialized with ${tools.length} tools (personality: ${personality}).`, { source: "Neo" });
         try {
-            this.agent = await ProviderFactory.create(neoConfig, tools);
+            this.agent = await ServiceContainer.get(SERVICE_KEYS.providerFactory).create(neoConfig, tools);
         }
         catch (err) {
             throw new ProviderError(neoConfig.provider, err, "Neo subagent initialization failed");