morpheus-cli 0.7.2 → 0.7.3

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

@@ -0,0 +1,201 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+// Define test directory as a static string path
+const TEST_DIR = process.cwd() + '/test-skills-registry';
+// Mock PATHS to use test directory
+vi.mock('../../../config/paths.js', () => ({
+    PATHS: {
+        skills: process.cwd() + '/test-skills-registry',
+    },
+}));
+// Import after mock setup
+import { SkillRegistry } from '../registry.js';
+/**
+ * Helper to create SKILL.md with YAML frontmatter
+ */
+function createSkillMd(dir, frontmatter, content = '') {
+    const lines = [];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (Array.isArray(value)) {
+            lines.push(`${key}:`);
+            for (const item of value) {
+                lines.push(`  - ${item}`);
+            }
+        }
+        else if (typeof value === 'boolean') {
+            lines.push(`${key}: ${value ? 'true' : 'false'}`);
+        }
+        else {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    const yaml = lines.join('\n');
+    const md = `---\n${yaml}\n---\n${content}`;
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), md);
+}
+describe('SkillRegistry', () => {
+    beforeEach(() => {
+        SkillRegistry.resetInstance();
+        fs.ensureDirSync(TEST_DIR);
+    });
+    afterEach(() => {
+        fs.removeSync(TEST_DIR);
+    });
+    describe('singleton pattern', () => {
+        it('should return the same instance', () => {
+            const instance1 = SkillRegistry.getInstance();
+            const instance2 = SkillRegistry.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+        it('should reset instance correctly', () => {
+            const instance1 = SkillRegistry.getInstance();
+            SkillRegistry.resetInstance();
+            const instance2 = SkillRegistry.getInstance();
+            expect(instance1).not.toBe(instance2);
+        });
+    });
+    describe('load()', () => {
+        it('should load skills from directory', async () => {
+            const skillDir = path.join(TEST_DIR, 'test-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'test-skill', description: 'Test skill' }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.getAll()).toHaveLength(1);
+            expect(registry.get('test-skill')).toBeDefined();
+        });
+        it('should clear previous skills on reload', async () => {
+            const skillDir = path.join(TEST_DIR, 'skill-a');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'skill-a', description: 'Skill A' }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.getAll()).toHaveLength(1);
+            // Remove the skill and reload
+            fs.removeSync(skillDir);
+            await registry.reload();
+            expect(registry.getAll()).toHaveLength(0);
+        });
+    });
+    describe('enable() / disable()', () => {
+        it('should enable a disabled skill', async () => {
+            const skillDir = path.join(TEST_DIR, 'toggle-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'toggle-skill', description: 'Toggle test', enabled: false }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.get('toggle-skill')?.enabled).toBe(false);
+            expect(registry.getEnabled()).toHaveLength(0);
+            const result = registry.enable('toggle-skill');
+            expect(result).toBe(true);
+            expect(registry.get('toggle-skill')?.enabled).toBe(true);
+            expect(registry.getEnabled()).toHaveLength(1);
+        });
+        it('should disable an enabled skill', async () => {
+            const skillDir = path.join(TEST_DIR, 'toggle-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'toggle-skill', description: 'Toggle test', enabled: true }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.get('toggle-skill')?.enabled).toBe(true);
+            const result = registry.disable('toggle-skill');
+            expect(result).toBe(true);
+            expect(registry.get('toggle-skill')?.enabled).toBe(false);
+            expect(registry.getEnabled()).toHaveLength(0);
+        });
+        it('should return false for non-existent skill', async () => {
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.enable('non-existent')).toBe(false);
+            expect(registry.disable('non-existent')).toBe(false);
+        });
+    });
+    describe('getEnabled()', () => {
+        it('should return only enabled skills', async () => {
+            // Create enabled skill
+            const enabledDir = path.join(TEST_DIR, 'enabled-skill');
+            fs.ensureDirSync(enabledDir);
+            createSkillMd(enabledDir, { name: 'enabled-skill', description: 'Enabled', enabled: true }, 'Instructions');
+            // Create disabled skill
+            const disabledDir = path.join(TEST_DIR, 'disabled-skill');
+            fs.ensureDirSync(disabledDir);
+            createSkillMd(disabledDir, { name: 'disabled-skill', description: 'Disabled', enabled: false }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            expect(registry.getAll()).toHaveLength(2);
+            expect(registry.getEnabled()).toHaveLength(1);
+            expect(registry.getEnabled()[0].name).toBe('enabled-skill');
+        });
+    });
+    describe('getSystemPromptSection()', () => {
+        it('should generate prompt section with sync 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();
+            await registry.load();
+            const section = registry.getSystemPromptSection();
+            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');
+        });
+        it('should return empty string when no skills', async () => {
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const section = registry.getSystemPromptSection();
+            expect(section).toBe('');
+        });
+        it('should not include disabled skills', async () => {
+            const skillDir = path.join(TEST_DIR, 'disabled-prompt');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'disabled-prompt',
+                description: 'Disabled skill',
+                enabled: false,
+            }, 'Instructions');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const section = registry.getSystemPromptSection();
+            expect(section).toBe('');
+        });
+    });
+    describe('getContent()', () => {
+        it('should return skill content from loaded skill', async () => {
+            const skillDir = path.join(TEST_DIR, 'content-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'content-skill', description: 'Test' }, '# Instructions\n\nDo the thing.');
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const content = registry.getContent('content-skill');
+            expect(content).toBe('# Instructions\n\nDo the thing.');
+        });
+        it('should return null for non-existent skill', async () => {
+            const registry = SkillRegistry.getInstance();
+            await registry.load();
+            const content = registry.getContent('non-existent');
+            expect(content).toBeNull();
+        });
+    });
+});

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

@@ -0,0 +1,266 @@
+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(() => ({
+    mockRegistry: {
+        get: vi.fn(),
+        getEnabled: vi.fn(() => []),
+        getContent: vi.fn(() => null),
+    },
+    mockRepository: {
+        createTask: vi.fn(),
+    },
+    mockDisplay: {
+        log: vi.fn(),
+    },
+    mockContext: {
+        get: vi.fn(() => ({
+            origin_channel: 'telegram',
+            session_id: 'test-session',
+            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', () => ({
+    SkillRegistry: {
+        getInstance: () => mockRegistry,
+    },
+}));
+vi.mock('../../tasks/repository.js', () => ({
+    TaskRepository: {
+        getInstance: () => mockRepository,
+    },
+}));
+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)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockRegistry.get.mockReset();
+        mockRegistry.getEnabled.mockReset();
+        mockKeymaker.executeKeymakerTask.mockReset();
+        mockKeymaker.executeKeymakerTask.mockResolvedValue('Keymaker result');
+        mockRegistry.getEnabled.mockReturnValue([]);
+    });
+    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)');
+        });
+    });
+    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');
+        });
+    });
+});
+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([]);
+    });
+    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)');
+        });
+    });
+    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();
+        });
+    });
+});

package/dist/runtime/skills/index.js

@@ -0,0 +1,8 @@
+/**
+ * Skills System - Public API
+ */
+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';

package/dist/runtime/skills/loader.js

@@ -0,0 +1,213 @@
+/**
+ * SkillLoader - Discovers and loads skills from filesystem
+ *
+ * Skills are SKILL.md files with YAML frontmatter containing metadata.
+ * Format:
+ * ---
+ * name: my-skill
+ * description: What this skill does
+ * execution_mode: sync
+ * ---
+ *
+ * # Skill Instructions...
+ */
+import fs from 'fs';
+import path from 'path';
+import { SkillMetadataSchema } from './schema.js';
+import { DisplayManager } from '../display.js';
+const SKILL_MD = 'SKILL.md';
+const MAX_SKILL_MD_SIZE = 50 * 1024; // 50KB
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/**
+ * Simple YAML frontmatter parser
+ * Handles basic key: value pairs and arrays
+ */
+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;
+        // Check for array item (indented with -)
+        if (trimmed.startsWith('- ') && currentKey && currentArray !== null) {
+            currentArray.push(trimmed.slice(2).trim().replace(/^["']|["']$/g, ''));
+            continue;
+        }
+        // Check for key: value
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            // Save previous array if exists
+            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 === '') {
+                // Could be start of array
+                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 {
+                // Remove quotes if present
+                result[key] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+    }
+    // Save last array if exists
+    if (currentKey && currentArray !== null && currentArray.length > 0) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
+export class SkillLoader {
+    skillsDir;
+    display = DisplayManager.getInstance();
+    constructor(skillsDir) {
+        this.skillsDir = skillsDir;
+    }
+    /**
+     * Scan skills directory and load all valid skills
+     */
+    async scan() {
+        const skills = [];
+        const errors = [];
+        // Check if skills directory exists
+        if (!fs.existsSync(this.skillsDir)) {
+            this.display.log(`Skills directory does not exist: ${this.skillsDir}`, {
+                source: 'SkillLoader',
+                level: 'debug',
+            });
+            return { skills, errors };
+        }
+        // Read directory contents
+        let entries;
+        try {
+            entries = fs.readdirSync(this.skillsDir, { withFileTypes: true });
+        }
+        catch (err) {
+            this.display.log(`Failed to read skills directory: ${err}`, {
+                source: 'SkillLoader',
+                level: 'error',
+            });
+            return { skills, errors };
+        }
+        // Process each subdirectory
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const dirPath = path.join(this.skillsDir, entry.name);
+            const result = this.loadSkillFromDir(dirPath, entry.name);
+            if (result.skill) {
+                skills.push(result.skill);
+            }
+            else if (result.error) {
+                errors.push(result.error);
+            }
+        }
+        return { skills, errors };
+    }
+    /**
+     * Load a single skill from a directory
+     */
+    loadSkillFromDir(dirPath, dirName) {
+        const mdPath = path.join(dirPath, SKILL_MD);
+        // Check SKILL.md exists
+        if (!fs.existsSync(mdPath)) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Missing ${SKILL_MD}`,
+                },
+            };
+        }
+        // Read SKILL.md content
+        let rawContent;
+        try {
+            const stats = fs.statSync(mdPath);
+            if (stats.size > MAX_SKILL_MD_SIZE) {
+                this.display.log(`SKILL.md for "${dirName}" exceeds ${MAX_SKILL_MD_SIZE / 1024}KB`, { source: 'SkillLoader', level: 'warning' });
+            }
+            rawContent = fs.readFileSync(mdPath, 'utf-8').slice(0, MAX_SKILL_MD_SIZE);
+        }
+        catch (err) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Failed to read ${SKILL_MD}: ${err instanceof Error ? err.message : String(err)}`,
+                    error: err instanceof Error ? err : undefined,
+                },
+            };
+        }
+        // Parse frontmatter
+        const match = rawContent.match(FRONTMATTER_REGEX);
+        if (!match) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Invalid format: ${SKILL_MD} must start with YAML frontmatter (--- ... ---)`,
+                },
+            };
+        }
+        const [, frontmatterYaml, content] = match;
+        // Parse YAML frontmatter
+        let rawMeta;
+        try {
+            rawMeta = parseFrontmatter(frontmatterYaml);
+        }
+        catch (err) {
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Invalid YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`,
+                    error: err instanceof Error ? err : undefined,
+                },
+            };
+        }
+        // Validate against schema
+        const parseResult = SkillMetadataSchema.safeParse(rawMeta);
+        if (!parseResult.success) {
+            const issues = parseResult.error.issues
+                .map((i) => `${i.path.join('.')}: ${i.message}`)
+                .join('; ');
+            return {
+                error: {
+                    directory: dirName,
+                    message: `Schema validation failed: ${issues}`,
+                },
+            };
+        }
+        const metadata = parseResult.data;
+        // Build Skill object
+        const skill = {
+            ...metadata,
+            path: mdPath,
+            dirName,
+            content: content.trim(),
+            enabled: metadata.enabled ?? true,
+            execution_mode: metadata.execution_mode ?? 'sync',
+        };
+        return { skill };
+    }
+    /**
+     * Read SKILL.md content for a skill (returns just the body, no frontmatter)
+     */
+    readContent(skill) {
+        return skill.content || null;
+    }
+}