morpheus-cli 0.9.5 → 0.9.7

package/dist/runtime/scaffold.js

@@ -22,7 +22,6 @@ This folder contains custom skills for Morpheus.
    ---
    name: my-skill
    description: What this skill does (max 500 chars)
-   execution_mode: sync
    version: 1.0.0
    author: your-name
    tags:
@@ -33,7 +32,7 @@ This folder contains custom skills for Morpheus.
 
    # My Skill
 
-   Instructions for Keymaker to follow when executing this skill.
+   Instructions for Oracle to follow when handling this skill.
 
    ## Steps
    1. First step
@@ -43,23 +42,11 @@ This folder contains custom skills for Morpheus.
    How to format the result.
    \`\`\`
 
-## Execution Modes
-
-| Mode | Tool | Description |
-|------|------|-------------|
-| sync | skill_execute | Result returned immediately (default) |
-| async | skill_delegate | Runs in background, notifies when done |
-
-**sync** (default): Best for quick tasks like code review, analysis.
-**async**: Best for long-running tasks like builds, deployments.
-
 ## How It Works
 
 - Oracle lists available skills in its system prompt
-- When a request matches a sync skill, Oracle calls \`skill_execute\`
-- When a request matches an async skill, Oracle calls \`skill_delegate\`
-- Keymaker has access to ALL tools (filesystem, shell, git, MCP, databases)
-- Keymaker follows SKILL.md instructions to complete the task
+- When a request matches a skill, Oracle calls \`load_skill\` to load its instructions
+- Oracle then follows the skill instructions using its existing tools (DevKit, MCP, databases, etc.)
 
 ## Frontmatter Schema
 
@@ -67,7 +54,6 @@ This folder contains custom skills for Morpheus.
 |-------|----------|---------|-------------|
 | name | Yes | - | Unique identifier (a-z, 0-9, hyphens) |
 | description | Yes | - | Short description (max 500 chars) |
-| execution_mode | No | sync | sync or async |
 | version | No | - | Semver (e.g., 1.0.0) |
 | author | No | - | Your name |
 | enabled | No | true | true/false |
@@ -85,6 +71,7 @@ export async function scaffold() {
             fs.ensureDir(PATHS.cache),
             fs.ensureDir(PATHS.commands),
             fs.ensureDir(PATHS.skills),
+            fs.ensureDir(PATHS.docs),
         ]);
         // Migrate config.yaml -> zaion.yaml if needed
         await migrateConfigFile();

package/dist/runtime/skills/__tests__/loader.test.js

@@ -53,7 +53,6 @@ describe('SkillLoader', () => {
                 version: '1.0.0',
                 author: 'Test Author',
                 enabled: true,
-                execution_mode: 'sync',
                 tags: ['test', 'unit'],
                 examples: ['do something', 'do another thing'],
             }, '# Test Skill\n\nInstructions here.');
@@ -66,7 +65,6 @@ describe('SkillLoader', () => {
             expect(skill.version).toBe('1.0.0');
             expect(skill.author).toBe('Test Author');
             expect(skill.enabled).toBe(true);
-            expect(skill.execution_mode).toBe('sync');
             expect(skill.tags).toEqual(['test', 'unit']);
             expect(skill.examples).toEqual(['do something', 'do another thing']);
             expect(skill.content).toBe('# Test Skill\n\nInstructions here.');
@@ -84,7 +82,6 @@ describe('SkillLoader', () => {
             const skill = result.skills[0];
             expect(skill.name).toBe('minimal-skill');
             expect(skill.enabled).toBe(true); // default
-            expect(skill.execution_mode).toBe('sync'); // default
         });
         it('should report error for missing SKILL.md', async () => {
             const skillDir = path.join(testDir, 'no-md-skill');
@@ -152,17 +149,17 @@ describe('SkillLoader', () => {
             expect(result.skills).toHaveLength(0);
             expect(result.errors).toHaveLength(0);
         });
-        it('should load async skill correctly', async () => {
-            const skillDir = path.join(testDir, 'async-skill');
+        it('should load skill with tags correctly', async () => {
+            const skillDir = path.join(testDir, 'tagged-skill');
             fs.ensureDirSync(skillDir);
             createSkillMd(skillDir, {
-                name: 'async-skill',
-                description: 'An async skill',
-                execution_mode: 'async',
-            }, 'Long-running task instructions');
+                name: 'tagged-skill',
+                description: 'A tagged skill',
+                tags: ['ops', 'deploy'],
+            }, 'Tagged task instructions');
             const result = await loader.scan();
             expect(result.skills).toHaveLength(1);
-            expect(result.skills[0].execution_mode).toBe('async');
+            expect(result.skills[0].tags).toEqual(['ops', 'deploy']);
         });
     });
     describe('content handling', () => {

package/dist/runtime/skills/__tests__/registry.test.js

@@ -129,13 +129,12 @@ describe('SkillRegistry', () => {
         });
     });
     describe('getSystemPromptSection()', () => {
-        it('should generate prompt section with sync skills', async () => {
+        it('should generate prompt section with skills', async () => {
             const skillDir = path.join(TEST_DIR, 'prompt-skill');
             fs.ensureDirSync(skillDir);
             createSkillMd(skillDir, {
                 name: 'prompt-skill',
                 description: 'A skill for prompts',
-                execution_mode: 'sync',
                 examples: ['example usage'],
             }, 'Instructions for prompt skill');
             const registry = SkillRegistry.getInstance();
@@ -144,22 +143,7 @@ describe('SkillRegistry', () => {
             expect(section).toContain('Available Skills');
             expect(section).toContain('prompt-skill');
             expect(section).toContain('A skill for prompts');
-            expect(section).toContain('skill_execute');
-        });
-        it('should generate prompt section with async skills', async () => {
-            const skillDir = path.join(TEST_DIR, 'async-skill');
-            fs.ensureDirSync(skillDir);
-            createSkillMd(skillDir, {
-                name: 'async-skill',
-                description: 'An async skill',
-                execution_mode: 'async',
-            }, 'Instructions for async skill');
-            const registry = SkillRegistry.getInstance();
-            await registry.load();
-            const section = registry.getSystemPromptSection();
-            expect(section).toContain('Async Skills');
-            expect(section).toContain('async-skill');
-            expect(section).toContain('skill_delegate');
+            expect(section).toContain('load_skill');
         });
         it('should return empty string when no skills', async () => {
             const registry = SkillRegistry.getInstance();

package/dist/runtime/skills/__tests__/tool.test.js

@@ -1,16 +1,12 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 // Use vi.hoisted to define mocks before they're used in vi.mock calls
-const { mockRegistry, mockRepository, mockDisplay, mockContext, mockKeymaker } = vi.hoisted(() => ({
+const { mockRegistry, mockAudit, mockContext } = vi.hoisted(() => ({
     mockRegistry: {
         get: vi.fn(),
         getEnabled: vi.fn(() => []),
-        getContent: vi.fn(() => null),
     },
-    mockRepository: {
-        createTask: vi.fn(),
-    },
-    mockDisplay: {
-        log: vi.fn(),
+    mockAudit: {
+        insert: vi.fn(),
     },
     mockContext: {
         get: vi.fn(() => ({
@@ -19,13 +15,6 @@ const { mockRegistry, mockRepository, mockDisplay, mockContext, mockKeymaker } =
             origin_message_id: '123',
             origin_user_id: 'user-1',
         })),
-        findDuplicateDelegation: vi.fn(() => null),
-        canEnqueueDelegation: vi.fn(() => true),
-        setDelegationAck: vi.fn(),
-    },
-    mockKeymaker: {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        executeKeymakerTask: vi.fn((_skill, _obj, _ctx) => Promise.resolve('Keymaker result')),
     },
 }));
 vi.mock('../registry.js', () => ({
@@ -33,234 +22,76 @@ vi.mock('../registry.js', () => ({
         getInstance: () => mockRegistry,
     },
 }));
-vi.mock('../../tasks/repository.js', () => ({
-    TaskRepository: {
-        getInstance: () => mockRepository,
+vi.mock('../../audit/repository.js', () => ({
+    AuditRepository: {
+        getInstance: () => mockAudit,
     },
 }));
 vi.mock('../../tasks/context.js', () => ({
     TaskRequestContext: mockContext,
 }));
-vi.mock('../../display.js', () => ({
-    DisplayManager: {
-        getInstance: () => mockDisplay,
-    },
-}));
-vi.mock('../../keymaker.js', () => ({
-    executeKeymakerTask: (skillName, objective, context) => mockKeymaker.executeKeymakerTask(skillName, objective, context),
-}));
 // Now import the module under test
-import { SkillExecuteTool, SkillDelegateTool, getSkillExecuteDescription, getSkillDelegateDescription } from '../tool.js';
-describe('SkillExecuteTool (sync)', () => {
+import { createLoadSkillTool } from '../tool.js';
+describe('load_skill tool', () => {
+    let loadSkillTool;
     beforeEach(() => {
         vi.clearAllMocks();
         mockRegistry.get.mockReset();
         mockRegistry.getEnabled.mockReset();
-        mockKeymaker.executeKeymakerTask.mockReset();
-        mockKeymaker.executeKeymakerTask.mockResolvedValue('Keymaker result');
         mockRegistry.getEnabled.mockReturnValue([]);
+        loadSkillTool = createLoadSkillTool();
     });
-    describe('getSkillExecuteDescription()', () => {
-        it('should include enabled sync skills in description', () => {
-            mockRegistry.getEnabled.mockReturnValue([
-                { name: 'code-review', description: 'Review code for issues', execution_mode: 'sync' },
-                { name: 'git-ops', description: 'Git operations helper', execution_mode: 'sync' },
-                { name: 'deploy', description: 'Deploy to prod', execution_mode: 'async' }, // should not appear
-            ]);
-            const description = getSkillExecuteDescription();
-            expect(description).toContain('code-review: Review code for issues');
-            expect(description).toContain('git-ops: Git operations helper');
-            expect(description).not.toContain('deploy');
-        });
-        it('should show no sync skills message when none enabled', () => {
-            mockRegistry.getEnabled.mockReturnValue([]);
-            const description = getSkillExecuteDescription();
-            expect(description).toContain('(no sync skills enabled)');
+    it('should return skill content for valid enabled skill', async () => {
+        mockRegistry.get.mockReturnValue({
+            name: 'test-skill',
+            description: 'Test',
+            enabled: true,
+            content: '# Instructions\n\nDo the thing.',
         });
+        const result = await loadSkillTool.invoke({ skillName: 'test-skill' });
+        expect(result).toContain('Loaded skill: test-skill');
+        expect(result).toContain('# Instructions');
+        expect(result).toContain('Do the thing.');
     });
-    describe('invoke()', () => {
-        it('should execute sync skill via Keymaker', async () => {
-            mockRegistry.get.mockReturnValue({
-                name: 'test-skill',
-                description: 'Test',
-                enabled: true,
-                execution_mode: 'sync',
-                content: 'Instructions here',
-            });
-            mockRegistry.getEnabled.mockReturnValue([{ name: 'test-skill', execution_mode: 'sync' }]);
-            const result = await SkillExecuteTool.invoke({
-                skillName: 'test-skill',
-                objective: 'do the thing',
-            });
-            expect(mockKeymaker.executeKeymakerTask).toHaveBeenCalledWith('test-skill', 'do the thing', expect.objectContaining({
-                origin_channel: 'telegram',
-                session_id: 'test-session',
-            }));
-            expect(result).toBe('Keymaker result');
-        });
-        it('should return error for non-existent skill', async () => {
-            mockRegistry.get.mockReturnValue(undefined);
-            mockRegistry.getEnabled.mockReturnValue([
-                { name: 'other-skill', execution_mode: 'sync' },
-            ]);
-            const result = await SkillExecuteTool.invoke({
-                skillName: 'non-existent',
-                objective: 'do something',
-            });
-            expect(result).toContain('Error');
-            expect(result).toContain('not found');
-            expect(result).toContain('other-skill');
-        });
-        it('should return error for async skill', async () => {
-            mockRegistry.get.mockReturnValue({
-                name: 'async-skill',
-                description: 'Async only',
-                enabled: true,
-                execution_mode: 'async',
-            });
-            const result = await SkillExecuteTool.invoke({
-                skillName: 'async-skill',
-                objective: 'do something',
-            });
-            expect(result).toContain('Error');
-            expect(result).toContain('async-only');
-            expect(result).toContain('skill_delegate');
+    it('should emit skill_loaded audit event', async () => {
+        mockRegistry.get.mockReturnValue({
+            name: 'test-skill',
+            description: 'Test',
+            enabled: true,
+            content: 'Instructions',
         });
+        await loadSkillTool.invoke({ skillName: 'test-skill' });
+        expect(mockAudit.insert).toHaveBeenCalledWith(expect.objectContaining({
+            event_type: 'skill_loaded',
+            agent: 'oracle',
+            tool_name: 'test-skill',
+            status: 'success',
+            session_id: 'test-session',
+        }));
     });
-});
-describe('SkillDelegateTool (async)', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockRegistry.get.mockReset();
-        mockRegistry.getEnabled.mockReset();
-        mockRepository.createTask.mockReset();
-        mockDisplay.log.mockReset();
-        mockContext.findDuplicateDelegation.mockReturnValue(null);
-        mockContext.canEnqueueDelegation.mockReturnValue(true);
-        mockRegistry.getEnabled.mockReturnValue([]);
+    it('should return error for non-existent skill', async () => {
+        mockRegistry.get.mockReturnValue(undefined);
+        mockRegistry.getEnabled.mockReturnValue([
+            { name: 'other-skill', description: 'Other' },
+        ]);
+        const result = await loadSkillTool.invoke({ skillName: 'non-existent' });
+        expect(result).toContain('not found');
+        expect(result).toContain('other-skill');
     });
-    describe('getSkillDelegateDescription()', () => {
-        it('should include enabled async skills in description', () => {
-            mockRegistry.getEnabled.mockReturnValue([
-                { name: 'deploy-staging', description: 'Deploy to staging', execution_mode: 'async' },
-                { name: 'batch-process', description: 'Process batch jobs', execution_mode: 'async' },
-                { name: 'code-review', description: 'Review code', execution_mode: 'sync' }, // should not appear
-            ]);
-            const description = getSkillDelegateDescription();
-            expect(description).toContain('deploy-staging: Deploy to staging');
-            expect(description).toContain('batch-process: Process batch jobs');
-            expect(description).not.toContain('code-review');
-        });
-        it('should show no async skills message when none enabled', () => {
-            mockRegistry.getEnabled.mockReturnValue([]);
-            const description = getSkillDelegateDescription();
-            expect(description).toContain('(no async skills enabled)');
+    it('should return error for disabled skill', async () => {
+        mockRegistry.get.mockReturnValue({
+            name: 'disabled-skill',
+            description: 'Disabled',
+            enabled: false,
         });
+        const result = await loadSkillTool.invoke({ skillName: 'disabled-skill' });
+        expect(result).toContain('disabled');
     });
-    describe('invoke()', () => {
-        it('should create task for valid async skill', async () => {
-            mockRegistry.get.mockReturnValue({
-                name: 'deploy-staging',
-                description: 'Deploy',
-                enabled: true,
-                execution_mode: 'async',
-            });
-            mockRegistry.getEnabled.mockReturnValue([{ name: 'deploy-staging', execution_mode: 'async' }]);
-            mockRepository.createTask.mockReturnValue({
-                id: 'task-123',
-                agent: 'keymaker',
-                status: 'pending',
-            });
-            const result = await SkillDelegateTool.invoke({
-                skillName: 'deploy-staging',
-                objective: 'deploy to staging',
-            });
-            expect(mockRepository.createTask).toHaveBeenCalledWith(expect.objectContaining({
-                agent: 'keymaker',
-                input: 'deploy to staging',
-                context: JSON.stringify({ skill: 'deploy-staging' }),
-                origin_channel: 'telegram',
-                session_id: 'test-session',
-            }));
-            expect(result).toContain('task-123');
-            expect(result).toContain('queued');
-        });
-        it('should return error for sync skill', async () => {
-            mockRegistry.get.mockReturnValue({
-                name: 'sync-skill',
-                description: 'Sync',
-                enabled: true,
-                execution_mode: 'sync',
-            });
-            const result = await SkillDelegateTool.invoke({
-                skillName: 'sync-skill',
-                objective: 'do something',
-            });
-            expect(result).toContain('Error');
-            expect(result).toContain('sync');
-            expect(result).toContain('skill_execute');
-            expect(mockRepository.createTask).not.toHaveBeenCalled();
-        });
-        it('should return error for non-existent skill', async () => {
-            mockRegistry.get.mockReturnValue(undefined);
-            mockRegistry.getEnabled.mockReturnValue([
-                { name: 'other-skill', execution_mode: 'async' },
-            ]);
-            const result = await SkillDelegateTool.invoke({
-                skillName: 'non-existent',
-                objective: 'do something',
-            });
-            expect(result).toContain('Error');
-            expect(result).toContain('not found');
-            expect(mockRepository.createTask).not.toHaveBeenCalled();
-        });
-        it('should return error for disabled skill', async () => {
-            mockRegistry.get.mockReturnValue({
-                name: 'disabled-skill',
-                description: 'Disabled',
-                enabled: false,
-                execution_mode: 'async',
-            });
-            const result = await SkillDelegateTool.invoke({
-                skillName: 'disabled-skill',
-                objective: 'do something',
-            });
-            expect(result).toContain('Error');
-            expect(result).toContain('disabled');
-            expect(mockRepository.createTask).not.toHaveBeenCalled();
-        });
-        it('should deduplicate delegation requests', async () => {
-            mockRegistry.get.mockReturnValue({
-                name: 'dup-skill',
-                enabled: true,
-                execution_mode: 'async',
-            });
-            mockContext.findDuplicateDelegation.mockReturnValue({
-                task_id: 'existing-task',
-                agent: 'keymaker',
-                task: 'dup-skill:objective',
-            });
-            const result = await SkillDelegateTool.invoke({
-                skillName: 'dup-skill',
-                objective: 'objective',
-            });
-            expect(result).toContain('existing-task');
-            expect(result).toContain('already queued');
-            expect(mockRepository.createTask).not.toHaveBeenCalled();
-        });
-        it('should block when delegation limit reached', async () => {
-            mockRegistry.get.mockReturnValue({
-                name: 'limit-skill',
-                enabled: true,
-                execution_mode: 'async',
-            });
-            mockContext.canEnqueueDelegation.mockReturnValue(false);
-            const result = await SkillDelegateTool.invoke({
-                skillName: 'limit-skill',
-                objective: 'objective',
-            });
-            expect(result).toContain('limit reached');
-            expect(mockRepository.createTask).not.toHaveBeenCalled();
-        });
+    it('should show no skills available when none enabled', async () => {
+        mockRegistry.get.mockReturnValue(undefined);
+        mockRegistry.getEnabled.mockReturnValue([]);
+        const result = await loadSkillTool.invoke({ skillName: 'anything' });
+        expect(result).toContain('not found');
+        expect(result).toContain('none');
     });
 });

package/dist/runtime/skills/index.js

@@ -4,5 +4,4 @@
 export { SkillRegistry } from './registry.js';
 export { SkillLoader } from './loader.js';
 export { SkillMetadataSchema } from './schema.js';
-export { SkillExecuteTool, SkillDelegateTool, getSkillExecuteDescription, getSkillDelegateDescription, updateSkillToolDescriptions, updateSkillDelegateDescription, // backwards compat
- } from './tool.js';
+export { createLoadSkillTool } from './tool.js';

package/dist/runtime/skills/loader.js

@@ -6,7 +6,6 @@
  * ---
  * name: my-skill
  * description: What this skill does
- * execution_mode: sync
  * ---
  *
  * # Skill Instructions...
@@ -200,7 +199,6 @@ export class SkillLoader {
             dirName,
             content: content.trim(),
             enabled: metadata.enabled ?? true,
-            execution_mode: metadata.execution_mode ?? 'sync',
         };
         return { skill };
     }

package/dist/runtime/skills/registry.js

@@ -107,26 +107,14 @@ export class SkillRegistry {
         if (enabled.length === 0) {
             return '';
         }
-        const syncSkills = enabled.filter((s) => s.execution_mode === 'sync');
-        const asyncSkills = enabled.filter((s) => s.execution_mode === 'async');
-        const lines = ['## Available Skills', ''];
-        if (syncSkills.length > 0) {
-            lines.push('### Sync Skills (immediate result via skill_execute)');
-            for (const s of syncSkills) {
-                lines.push(`- **${s.name}**: ${s.description}`);
-            }
-            lines.push('');
-        }
-        if (asyncSkills.length > 0) {
-            lines.push('### Async Skills (background task via skill_delegate)');
-            for (const s of asyncSkills) {
-                lines.push(`- **${s.name}**: ${s.description}`);
-            }
-            lines.push('');
-        }
-        lines.push('Use `skill_execute(skillName, objective)` for sync skills — result returned immediately.');
-        lines.push('Use `skill_delegate(skillName, objective)` for async skills — runs in background, notifies when done.');
-        return lines.join('\n');
+        const skillList = enabled
+            .map(s => `- **${s.name}**: ${s.description}`)
+            .join('\n');
+        return `## Available Skills
+
+${skillList}
+
+Use the \`load_skill\` tool when you need detailed instructions for handling a specific type of request.`;
     }
     /**
      * Get skill names for tool description

package/dist/runtime/skills/schema.js

@@ -15,10 +15,6 @@ export const SkillMetadataSchema = z.object({
         .string()
         .min(1, 'Description is required')
         .max(500, 'Description must be at most 500 characters'),
-    execution_mode: z
-        .enum(['sync', 'async'])
-        .default('sync')
-        .describe('Execution mode: sync returns result inline, async creates background task'),
     version: z
         .string()
         .regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format (e.g., 1.0.0)')