morpheus-cli 0.7.2 → 0.7.4

package/dist/http/routers/skills.js

@@ -0,0 +1,291 @@
+import { Router } from 'express';
+import multer from 'multer';
+import extract from 'extract-zip';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { SkillRegistry, updateSkillDelegateDescription } from '../../runtime/skills/index.js';
+import { DisplayManager } from '../../runtime/display.js';
+import { PATHS } from '../../config/paths.js';
+import { SkillMetadataSchema } from '../../runtime/skills/schema.js';
+// Multer config for ZIP uploads
+const upload = multer({
+    storage: multer.memoryStorage(),
+    limits: { fileSize: 10 * 1024 * 1024 }, // 10MB max
+    fileFilter: (_req, file, cb) => {
+        if (file.mimetype === 'application/zip' || file.mimetype === 'application/x-zip-compressed' || file.originalname.endsWith('.zip')) {
+            cb(null, true);
+        }
+        else {
+            cb(new Error('Only ZIP files are allowed'));
+        }
+    },
+});
+// YAML frontmatter regex
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/**
+ * Simple YAML frontmatter parser
+ */
+function parseFrontmatter(yaml) {
+    const result = {};
+    const lines = yaml.split('\n');
+    let currentKey = null;
+    let currentArray = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        if (trimmed.startsWith('- ') && currentKey && currentArray !== null) {
+            currentArray.push(trimmed.slice(2).trim().replace(/^["']|["']$/g, ''));
+            continue;
+        }
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            if (currentKey && currentArray !== null && currentArray.length > 0) {
+                result[currentKey] = currentArray;
+            }
+            currentArray = null;
+            const key = line.slice(0, colonIndex).trim();
+            const value = line.slice(colonIndex + 1).trim();
+            currentKey = key;
+            if (value === '') {
+                currentArray = [];
+            }
+            else if (value === 'true') {
+                result[key] = true;
+            }
+            else if (value === 'false') {
+                result[key] = false;
+            }
+            else if (/^\d+$/.test(value)) {
+                result[key] = parseInt(value, 10);
+            }
+            else if (/^\d+\.\d+$/.test(value)) {
+                result[key] = parseFloat(value);
+            }
+            else {
+                result[key] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+    }
+    if (currentKey && currentArray !== null && currentArray.length > 0) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
+/**
+ * Create the skills API router
+ *
+ * Endpoints:
+ * - GET /api/skills - List all skills
+ * - GET /api/skills/:name - Get single skill with content
+ * - POST /api/skills/reload - Reload skills from filesystem
+ * - POST /api/skills/upload - Upload a skill ZIP
+ * - POST /api/skills/:name/enable - Enable a skill
+ * - POST /api/skills/:name/disable - Disable a skill
+ */
+export function createSkillsRouter() {
+    const router = Router();
+    const display = DisplayManager.getInstance();
+    // GET /api/skills - List all skills
+    router.get('/', (_req, res) => {
+        try {
+            const registry = SkillRegistry.getInstance();
+            const skills = registry.getAll();
+            const response = skills.map(skill => ({
+                name: skill.name,
+                description: skill.description,
+                version: skill.version,
+                author: skill.author,
+                enabled: skill.enabled,
+                tags: skill.tags,
+                examples: skill.examples,
+                path: skill.path,
+            }));
+            res.json({
+                skills: response,
+                total: skills.length,
+                enabled: skills.filter(s => s.enabled).length,
+            });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/skills/reload - Reload from filesystem
+    // Must be before /:name routes
+    router.post('/reload', async (_req, res) => {
+        try {
+            const registry = SkillRegistry.getInstance();
+            const result = await registry.reload();
+            // Update skill_delegate tool description with new skills
+            updateSkillDelegateDescription();
+            display.log(`Skills reloaded: ${result.skills.length} loaded, ${result.errors.length} errors`, {
+                source: 'SkillsAPI',
+            });
+            res.json({
+                success: true,
+                loaded: result.skills.length,
+                errors: result.errors.map(e => ({
+                    directory: e.directory,
+                    message: e.message,
+                })),
+            });
+        }
+        catch (err) {
+            display.log(`Skills reload error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/skills/upload - Upload a skill ZIP
+    // Must be before /:name routes
+    router.post('/upload', upload.single('file'), async (req, res) => {
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'morpheus-skill-'));
+        try {
+            if (!req.file) {
+                return res.status(400).json({ error: 'No file uploaded' });
+            }
+            const zipPath = path.join(tempDir, 'skill.zip');
+            const extractDir = path.join(tempDir, 'extracted');
+            // Write buffer to temp file
+            await fs.writeFile(zipPath, req.file.buffer);
+            // Extract ZIP
+            await extract(zipPath, { dir: extractDir });
+            // Find root entries
+            const entries = await fs.readdir(extractDir, { withFileTypes: true });
+            const folders = entries.filter(e => e.isDirectory());
+            const files = entries.filter(e => e.isFile());
+            // Validate: exactly one folder at root, no loose files
+            if (folders.length !== 1 || files.length > 0) {
+                return res.status(400).json({
+                    error: 'Invalid ZIP structure',
+                    details: 'ZIP must contain exactly one folder at root level (no loose files)',
+                });
+            }
+            const skillFolderName = folders[0].name;
+            const skillFolderPath = path.join(extractDir, skillFolderName);
+            // Check for SKILL.md
+            const skillMdPath = path.join(skillFolderPath, 'SKILL.md');
+            if (!await fs.pathExists(skillMdPath)) {
+                return res.status(400).json({
+                    error: 'Missing SKILL.md',
+                    details: `Folder "${skillFolderName}" must contain a SKILL.md file`,
+                });
+            }
+            // Read and validate SKILL.md frontmatter
+            const skillMdContent = await fs.readFile(skillMdPath, 'utf-8');
+            const match = skillMdContent.match(FRONTMATTER_REGEX);
+            if (!match) {
+                return res.status(400).json({
+                    error: 'Invalid SKILL.md format',
+                    details: 'SKILL.md must have YAML frontmatter between --- delimiters',
+                });
+            }
+            const [, frontmatterYaml] = match;
+            const rawMetadata = parseFrontmatter(frontmatterYaml);
+            // Validate with Zod schema
+            const parseResult = SkillMetadataSchema.safeParse(rawMetadata);
+            if (!parseResult.success) {
+                const issues = parseResult.error.issues.map(i => `${i.path.join('.')}: ${i.message}`);
+                return res.status(400).json({
+                    error: 'Invalid skill metadata',
+                    details: issues.join('; '),
+                });
+            }
+            const metadata = parseResult.data;
+            // Check if skill already exists
+            const targetPath = path.join(PATHS.skills, metadata.name);
+            if (await fs.pathExists(targetPath)) {
+                return res.status(409).json({
+                    error: 'Skill already exists',
+                    details: `A skill named "${metadata.name}" already exists. Delete it first or choose a different name.`,
+                });
+            }
+            // Copy to skills directory
+            await fs.copy(skillFolderPath, targetPath);
+            // Reload skills
+            const registry = SkillRegistry.getInstance();
+            await registry.reload();
+            updateSkillDelegateDescription();
+            display.log(`Skill "${metadata.name}" uploaded successfully`, { source: 'SkillsAPI' });
+            res.json({
+                success: true,
+                skill: {
+                    name: metadata.name,
+                    description: metadata.description,
+                    version: metadata.version,
+                    author: metadata.author,
+                    path: targetPath,
+                },
+            });
+        }
+        catch (err) {
+            display.log(`Skill upload error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.remove(tempDir).catch(() => { });
+        }
+    });
+    // GET /api/skills/:name - Get single skill with content
+    router.get('/:name', (req, res) => {
+        try {
+            const { name } = req.params;
+            const registry = SkillRegistry.getInstance();
+            const skill = registry.get(name);
+            if (!skill) {
+                return res.status(404).json({ error: `Skill "${name}" not found` });
+            }
+            const content = registry.getContent(name);
+            res.json({
+                ...skill,
+                content: content || null,
+            });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/skills/:name/enable - Enable a skill
+    router.post('/:name/enable', (req, res) => {
+        try {
+            const { name } = req.params;
+            const registry = SkillRegistry.getInstance();
+            const success = registry.enable(name);
+            if (!success) {
+                return res.status(404).json({ error: `Skill "${name}" not found` });
+            }
+            // Update skill_delegate tool description
+            updateSkillDelegateDescription();
+            display.log(`Skill "${name}" enabled`, { source: 'SkillsAPI' });
+            res.json({ success: true, name, enabled: true });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/skills/:name/disable - Disable a skill
+    router.post('/:name/disable', (req, res) => {
+        try {
+            const { name } = req.params;
+            const registry = SkillRegistry.getInstance();
+            const success = registry.disable(name);
+            if (!success) {
+                return res.status(404).json({ error: `Skill "${name}" not found` });
+            }
+            // Update skill_delegate tool description
+            updateSkillDelegateDescription();
+            display.log(`Skill "${name}" disabled`, { source: 'SkillsAPI' });
+            res.json({ success: true, name, enabled: false });
+        }
+        catch (err) {
+            display.log(`Skills API error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Keymaker, executeKeymakerTask } from '../keymaker.js';
+import { SkillRegistry } from '../skills/registry.js';
+// Mock all heavy dependencies
+vi.mock('../skills/registry.js', () => ({
+    SkillRegistry: {
+        getInstance: vi.fn(),
+    },
+}));
+vi.mock('../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: vi.fn(() => ({
+            get: vi.fn(() => ({
+                llm: {
+                    provider: 'openai',
+                    model: 'gpt-4o',
+                    temperature: 0.7,
+                },
+                keymaker: {
+                    provider: 'openai',
+                    model: 'gpt-4o',
+                    personality: 'versatile_specialist',
+                },
+            })),
+        })),
+    },
+}));
+vi.mock('../display.js', () => ({
+    DisplayManager: {
+        getInstance: vi.fn(() => ({
+            log: vi.fn(),
+        })),
+    },
+}));
+vi.mock('../../devkit/index.js', () => ({
+    buildDevKit: vi.fn(() => [
+        { name: 'fs_read', description: 'Read file' },
+        { name: 'shell_exec', description: 'Execute shell command' },
+    ]),
+}));
+vi.mock('../tools/factory.js', () => ({
+    Construtor: {
+        create: vi.fn(() => Promise.resolve([
+            { name: 'mcp_tool', description: 'MCP tool' },
+        ])),
+    },
+}));
+vi.mock('../tools/index.js', () => ({
+    morpheusTools: [
+        { name: 'morpheus_tool', description: 'Internal tool' },
+    ],
+}));
+vi.mock('../providers/factory.js', () => ({
+    ProviderFactory: {
+        createBare: vi.fn(() => Promise.resolve({
+            invoke: vi.fn(),
+        })),
+    },
+}));
+vi.mock('../memory/sqlite.js', () => {
+    return {
+        SQLiteChatMessageHistory: class MockSQLiteChatMessageHistory {
+            addMessage = vi.fn();
+            close = vi.fn();
+        },
+    };
+});
+describe('Keymaker', () => {
+    const mockRegistry = {
+        get: vi.fn(),
+        getContent: vi.fn(),
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        SkillRegistry.getInstance.mockReturnValue(mockRegistry);
+        mockRegistry.get.mockReturnValue({
+            name: 'test-skill',
+            description: 'A test skill',
+            tags: ['test'],
+            enabled: true,
+        });
+        mockRegistry.getContent.mockReturnValue('# Test Skill\n\nInstructions here.');
+    });
+    describe('constructor', () => {
+        it('should create instance with skill name and content', () => {
+            const keymaker = new Keymaker('test-skill', '# Instructions');
+            expect(keymaker).toBeInstanceOf(Keymaker);
+        });
+        it('should accept custom config', () => {
+            const customConfig = {
+                llm: { provider: 'anthropic', model: 'claude-3' },
+            };
+            const keymaker = new Keymaker('test-skill', '# Instructions', customConfig);
+            expect(keymaker).toBeInstanceOf(Keymaker);
+        });
+    });
+    describe('initialize()', () => {
+        it('should initialize agent with all tools', async () => {
+            const { ProviderFactory } = await import('../providers/factory.js');
+            const { buildDevKit } = await import('../../devkit/index.js');
+            const { Construtor } = await import('../tools/factory.js');
+            const keymaker = new Keymaker('test-skill', '# Instructions');
+            await keymaker.initialize();
+            expect(buildDevKit).toHaveBeenCalled();
+            expect(Construtor.create).toHaveBeenCalled();
+            expect(ProviderFactory.createBare).toHaveBeenCalled();
+            // Verify tools were combined
+            const createBareCall = ProviderFactory.createBare.mock.calls[0];
+            const tools = createBareCall[1];
+            // Should have DevKit (2) + MCP (1) + Morpheus (1) = 4 tools
+            expect(tools.length).toBe(4);
+        });
+    });
+});
+describe('executeKeymakerTask', () => {
+    const mockRegistry = {
+        get: vi.fn(),
+        getContent: vi.fn(),
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        SkillRegistry.getInstance.mockReturnValue(mockRegistry);
+    });
+    it('should throw error when SKILL.md not found', async () => {
+        mockRegistry.getContent.mockReturnValue(null);
+        await expect(executeKeymakerTask('missing-skill', 'do something')).rejects.toThrow('SKILL.md not found for skill: missing-skill');
+    });
+    it('should create and execute keymaker with skill content', async () => {
+        mockRegistry.getContent.mockReturnValue('# Test Instructions\n\nDo this.');
+        mockRegistry.get.mockReturnValue({
+            name: 'test-skill',
+            description: 'Test skill',
+            enabled: true,
+        });
+        const { ProviderFactory } = await import('../providers/factory.js');
+        ProviderFactory.createBare.mockResolvedValue({
+            invoke: vi.fn().mockResolvedValue({
+                messages: [{ content: 'Task completed successfully.' }],
+            }),
+        });
+        const result = await executeKeymakerTask('test-skill', 'do the task');
+        expect(mockRegistry.getContent).toHaveBeenCalledWith('test-skill');
+        expect(result).toBe('Task completed successfully.');
+    });
+});

package/dist/runtime/keymaker.js

@@ -0,0 +1,162 @@
+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 { buildDevKit } from "../devkit/index.js";
+import { Construtor } from "./tools/factory.js";
+import { morpheusTools } from "./tools/index.js";
+import { SkillRegistry } from "./skills/registry.js";
+import { TaskRequestContext } from "./tasks/context.js";
+import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
+/**
+ * Keymaker is a specialized agent for executing skills.
+ * "The one who opens any door" - has access to ALL tools:
+ * - DevKit (filesystem, shell, git, browser, network, processes, packages, system)
+ * - MCP tools (all configured MCP servers)
+ * - Morpheus internal tools
+ *
+ * Keymaker is instantiated per-task with a specific skill's SKILL.md as context.
+ * It executes the skill instructions autonomously and returns the result.
+ */
+export class Keymaker {
+    agent;
+    config;
+    display = DisplayManager.getInstance();
+    skillName;
+    skillContent;
+    constructor(skillName, skillContent, config) {
+        this.skillName = skillName;
+        this.skillContent = skillContent;
+        this.config = config || ConfigManager.getInstance().get();
+    }
+    async initialize() {
+        const keymakerConfig = this.config.keymaker || this.config.llm;
+        const personality = this.config.keymaker?.personality || 'versatile_specialist';
+        // Build DevKit tools (filesystem, shell, git, browser, network, etc.)
+        const working_dir = process.cwd();
+        const timeout_ms = 30_000;
+        await import("../devkit/index.js");
+        const devKitTools = buildDevKit({
+            working_dir,
+            allowed_commands: [], // no restriction
+            timeout_ms,
+        });
+        // Load MCP tools from configured servers
+        const mcpTools = await Construtor.create();
+        // Combine all tools
+        const tools = [...devKitTools, ...mcpTools, ...morpheusTools];
+        this.display.log(`Keymaker initialized for skill "${this.skillName}" with ${tools.length} tools (personality: ${personality})`, { source: "Keymaker" });
+        try {
+            this.agent = await ProviderFactory.createBare(keymakerConfig, tools);
+        }
+        catch (err) {
+            throw new ProviderError(keymakerConfig.provider, err, "Keymaker agent initialization failed");
+        }
+    }
+    /**
+     * Execute the skill with the given objective.
+     * @param objective User's task description
+     * @param taskContext Context for routing responses
+     */
+    async execute(objective, taskContext) {
+        if (!this.agent) {
+            await this.initialize();
+        }
+        this.display.log(`Keymaker executing skill "${this.skillName}": ${objective.slice(0, 80)}...`, { source: "Keymaker" });
+        const personality = this.config.keymaker?.personality || 'versatile_specialist';
+        const registry = SkillRegistry.getInstance();
+        const skill = registry.get(this.skillName);
+        const systemMessage = new SystemMessage(`
+You are Keymaker, ${personality === 'versatile_specialist' ? 'a versatile specialist who can open any door' : personality}, executing the "${this.skillName}" skill.
+
+You have access to ALL tools:
+- Filesystem: read, write, list, delete, copy, move files and directories
+- Shell: execute commands, spawn processes
+- Git: clone, commit, push, pull, branch, diff
+- Network: HTTP requests, health checks
+- Browser: navigate, screenshot, extract content
+- MCP tools: all configured MCP server tools
+- System: CPU, memory, disk info
+
+## Skill: ${skill?.description || this.skillName}
+${skill?.tags?.length ? `Tags: ${skill.tags.join(', ')}` : ''}
+
+## Skill Instructions
+${this.skillContent}
+
+## Your Objective
+${objective}
+
+IMPORTANT:
+1. Follow the skill instructions carefully to accomplish the objective.
+2. Be thorough and autonomous. Use the tools at your disposal.
+3. If you encounter errors, try alternative approaches.
+4. Provide a clear summary of what was accomplished.
+5. Respond in the same language as the objective.
+
+CRITICAL — NEVER FABRICATE DATA:
+- If none of your available tools can retrieve the requested information, state this clearly.
+- NEVER generate fake data, fake IDs, fake results of any kind.
+- An honest "I cannot do this" is always correct. A fabricated answer is never acceptable.
+    `);
+        const userMessage = new HumanMessage(objective);
+        const messages = [systemMessage, userMessage];
+        try {
+            const invokeContext = {
+                origin_channel: taskContext?.origin_channel ?? "api",
+                session_id: taskContext?.session_id ?? "keymaker",
+                origin_message_id: taskContext?.origin_message_id,
+                origin_user_id: taskContext?.origin_user_id,
+            };
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }));
+            const lastMessage = response.messages[response.messages.length - 1];
+            const content = typeof lastMessage.content === "string"
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+            // Persist message with token usage metadata (like Trinity/Neo/Apoc)
+            const keymakerConfig = this.config.keymaker || this.config.llm;
+            const targetSession = taskContext?.session_id ?? "keymaker";
+            const history = new SQLiteChatMessageHistory({ sessionId: targetSession });
+            try {
+                const persisted = new AIMessage(content);
+                persisted.usage_metadata =
+                    lastMessage.usage_metadata ??
+                        lastMessage.response_metadata?.usage ??
+                        lastMessage.response_metadata?.tokenUsage ??
+                        lastMessage.usage;
+                persisted.provider_metadata = {
+                    provider: keymakerConfig.provider,
+                    model: keymakerConfig.model,
+                };
+                await history.addMessage(persisted);
+            }
+            finally {
+                history.close();
+            }
+            this.display.log(`Keymaker completed skill "${this.skillName}" execution`, { source: "Keymaker" });
+            return content;
+        }
+        catch (err) {
+            this.display.log(`Keymaker execution error: ${err.message}`, { source: "Keymaker", level: "error" });
+            throw err;
+        }
+    }
+}
+/**
+ * Factory function to create and execute a Keymaker task.
+ * Used by TaskWorker when routing keymaker tasks.
+ *
+ * @param skillName Name of the skill to execute
+ * @param objective User's task description
+ * @param taskContext Optional context for routing responses
+ */
+export async function executeKeymakerTask(skillName, objective, taskContext) {
+    const registry = SkillRegistry.getInstance();
+    const skillContent = registry.getContent(skillName);
+    if (!skillContent) {
+        throw new Error(`SKILL.md not found for skill: ${skillName}`);
+    }
+    const keymaker = new Keymaker(skillName, skillContent);
+    return keymaker.execute(objective, taskContext);
+}

package/dist/runtime/oracle.js

@@ -15,6 +15,7 @@ import { ApocDelegateTool } from "./tools/apoc-tool.js";
 import { TrinityDelegateTool } from "./tools/trinity-tool.js";
 import { TaskQueryTool, chronosTools, timeVerifierTool } from "./tools/index.js";
 import { MCPManager } from "../config/mcp-manager.js";
+import { SkillRegistry, SkillExecuteTool, SkillDelegateTool, updateSkillToolDescriptions } from "./skills/index.js";
 export class Oracle {
     provider;
     config;
@@ -143,7 +144,8 @@ export class Oracle {
             // Fail-open: Oracle can still initialize even if catalog refresh fails.
             await Neo.refreshDelegateCatalog().catch(() => { });
             await Trinity.refreshDelegateCatalog().catch(() => { });
-            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, timeVerifierTool, ...chronosTools]);
+            updateSkillToolDescriptions();
+            this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, timeVerifierTool, ...chronosTools]);
             if (!this.provider) {
                 throw new Error("Provider factory returned undefined");
             }
@@ -291,6 +293,8 @@ good:
 - Answer directly acknowledging the fact. Do NOT delegate.
 bad:
 - delegate to "neo_delegate" or "apoc_delegate" to save the fact. (Sati handles this automatically in the background)
+
+${SkillRegistry.getInstance().getSystemPromptSection()}
 `);
             // Load existing history from database in reverse order (most recent first)
             let previousMessages = await this.history.getMessages();
@@ -337,9 +341,11 @@ Use it to inform your response and tool selection (if needed), but do not assume
                 origin_user_id: taskContext?.origin_user_id,
             };
             let contextDelegationAcks = [];
+            let syncDelegationCount = 0;
             const response = await TaskRequestContext.run(invokeContext, async () => {
                 const agentResponse = await this.provider.invoke({ messages });
                 contextDelegationAcks = TaskRequestContext.getDelegationAcks();
+                syncDelegationCount = TaskRequestContext.getSyncDelegationCount();
                 return agentResponse;
             });
             // Identify new messages generated during the interaction
@@ -360,13 +366,17 @@ Use it to inform your response and tool selection (if needed), but do not assume
             const toolDelegationAcks = this.extractDelegationAcksFromMessages(newGeneratedMessages);
             const hadDelegationToolCall = this.hasDelegationToolCall(newGeneratedMessages);
             const hadChronosToolCall = this.hasChronosToolCall(newGeneratedMessages);
+            // When all delegation tool calls ran synchronously, there are no task IDs to validate.
+            // Treat as a normal (non-delegation) response so the inline result flows through.
+            const allDelegationsSyncInline = hadDelegationToolCall && syncDelegationCount > 0
+                && contextDelegationAcks.length === 0;
             const mergedDelegationAcks = [
                 ...contextDelegationAcks.map((ack) => ({ task_id: ack.task_id, agent: ack.agent })),
                 ...toolDelegationAcks,
             ];
             const validDelegationAcks = this.validateDelegationAcks(mergedDelegationAcks, message);
             if (mergedDelegationAcks.length > 0) {
-                this.display.log(`Delegation trace: context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, valid=${validDelegationAcks.length}`, { source: "Oracle", level: "info" });
+                this.display.log(`Delegation trace: context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, valid=${validDelegationAcks.length}, sync_inline=${syncDelegationCount}`, { source: "Oracle", level: "info" });
             }
             const delegatedThisTurn = validDelegationAcks.length > 0;
             let blockedSyntheticDelegationAck = false;
@@ -388,7 +398,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
                 // returned to the caller (Telegram / UI) immediately after this point.
                 this.taskRepository.markAckSent(validDelegationAcks.map(a => a.task_id));
             }
-            else if (mergedDelegationAcks.length > 0 || hadDelegationToolCall) {
+            else if (!allDelegationsSyncInline && (mergedDelegationAcks.length > 0 || hadDelegationToolCall)) {
                 this.display.log(`Delegation attempted but no valid task id was confirmed (context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, had_tool_call=${hadDelegationToolCall}).`, { source: "Oracle", level: "error" });
                 // Delegation was attempted but no valid task id could be confirmed in DB.
                 responseContent = this.buildDelegationFailureResponse();
@@ -538,7 +548,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
         }
         await Neo.refreshDelegateCatalog().catch(() => { });
         await Trinity.refreshDelegateCatalog().catch(() => { });
-        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, ...chronosTools]);
+        updateSkillToolDescriptions();
+        this.provider = await ProviderFactory.create(this.config.llm, [TaskQueryTool, NeoDelegateTool, ApocDelegateTool, TrinityDelegateTool, SkillExecuteTool, SkillDelegateTool, ...chronosTools]);
         await Neo.getInstance().reload();
         this.display.log(`Oracle and Neo tools reloaded`, { source: 'Oracle' });
     }