morpheus-cli 0.7.2 → 0.7.3

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();
@@ -538,7 +542,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' });
     }

package/dist/runtime/scaffold.js

@@ -1,10 +1,79 @@
 import fs from 'fs-extra';
+import path from 'path';
 import { PATHS } from '../config/paths.js';
 import { ConfigManager } from '../config/manager.js';
 import { DEFAULT_MCP_TEMPLATE } from '../types/mcp.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { migrateConfigFile } from './migration.js';
+const SKILLS_README = `# Morpheus Skills
+
+This folder contains custom skills for Morpheus.
+
+## Creating a Skill
+
+1. Create a folder with your skill name (lowercase, hyphens allowed):
+   \`\`\`
+   mkdir my-skill
+   \`\`\`
+
+2. Create \`SKILL.md\` with YAML frontmatter + instructions:
+   \`\`\`markdown
+   ---
+   name: my-skill
+   description: What this skill does (max 500 chars)
+   execution_mode: sync
+   version: 1.0.0
+   author: your-name
+   tags:
+     - category
+   examples:
+     - "Example request that triggers this skill"
+   ---
+
+   # My Skill
+
+   Instructions for Keymaker to follow when executing this skill.
+
+   ## Steps
+   1. First step
+   2. Second step
+
+   ## Output Format
+   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
+
+## Frontmatter Schema
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| 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 |
+| tags | No | - | Array of tags (max 10) |
+| examples | No | - | Example requests (max 5) |
+`;
 export async function scaffold() {
     const spinner = ora('Ensuring Morpheus environment...').start();
     try {
@@ -15,6 +84,7 @@ export async function scaffold() {
             fs.ensureDir(PATHS.memory),
             fs.ensureDir(PATHS.cache),
             fs.ensureDir(PATHS.commands),
+            fs.ensureDir(PATHS.skills),
         ]);
         // Migrate config.yaml -> zaion.yaml if needed
         await migrateConfigFile();
@@ -30,6 +100,11 @@ export async function scaffold() {
         if (!(await fs.pathExists(PATHS.mcps))) {
             await fs.writeJson(PATHS.mcps, DEFAULT_MCP_TEMPLATE, { spaces: 2 });
         }
+        // Create skills README if not exists
+        const skillsReadme = path.join(PATHS.skills, 'README.md');
+        if (!(await fs.pathExists(skillsReadme))) {
+            await fs.writeFile(skillsReadme, SKILLS_README, 'utf-8');
+        }
         spinner.succeed('Morpheus environment ready at ' + chalk.cyan(PATHS.root));
     }
     catch (error) {

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

@@ -0,0 +1,187 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SkillLoader } from '../loader.js';
+import fs from 'fs-extra';
+import path from 'path';
+/**
+ * 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 {
+            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('SkillLoader', () => {
+    const testDir = path.join(process.cwd(), 'test-skills');
+    let loader;
+    beforeEach(() => {
+        fs.ensureDirSync(testDir);
+        loader = new SkillLoader(testDir);
+    });
+    afterEach(() => {
+        fs.removeSync(testDir);
+    });
+    describe('scan()', () => {
+        it('should return empty list for non-existent directory', async () => {
+            fs.removeSync(testDir);
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should return empty list for empty directory', async () => {
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should load valid skill with all metadata', async () => {
+            const skillDir = path.join(testDir, 'test-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'test-skill',
+                description: 'A test skill for unit testing',
+                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.');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.errors).toHaveLength(0);
+            const skill = result.skills[0];
+            expect(skill.name).toBe('test-skill');
+            expect(skill.description).toBe('A test skill for unit testing');
+            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.');
+        });
+        it('should load skill with minimal metadata (defaults)', async () => {
+            const skillDir = path.join(testDir, 'minimal-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'minimal-skill',
+                description: 'A minimal skill',
+            }, 'Minimal instructions');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.errors).toHaveLength(0);
+            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');
+            fs.ensureDirSync(skillDir);
+            // No SKILL.md file created
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].directory).toBe('no-md-skill');
+            expect(result.errors[0].message).toContain('Missing SKILL.md');
+        });
+        it('should report error for SKILL.md without frontmatter', async () => {
+            const skillDir = path.join(testDir, 'no-frontmatter');
+            fs.ensureDirSync(skillDir);
+            fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '# No Frontmatter\n\nJust plain markdown.');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].directory).toBe('no-frontmatter');
+            expect(result.errors[0].message).toContain('Invalid format');
+        });
+        it('should report error for schema validation failure', async () => {
+            const skillDir = path.join(testDir, 'bad-schema');
+            fs.ensureDirSync(skillDir);
+            // Missing required 'description' field
+            createSkillMd(skillDir, {
+                name: 'bad-schema',
+            }, 'No description provided');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].message).toContain('Schema validation failed');
+        });
+        it('should reject invalid skill name format', async () => {
+            const skillDir = path.join(testDir, 'invalid-name');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'Invalid Name With Spaces!',
+                description: 'Should fail validation',
+            }, 'Content');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0].message).toContain('Schema validation failed');
+        });
+        it('should load multiple skills', async () => {
+            // Create skill 1
+            const skill1Dir = path.join(testDir, 'skill-one');
+            fs.ensureDirSync(skill1Dir);
+            createSkillMd(skill1Dir, { name: 'skill-one', description: 'First skill' }, 'Instructions 1');
+            // Create skill 2
+            const skill2Dir = path.join(testDir, 'skill-two');
+            fs.ensureDirSync(skill2Dir);
+            createSkillMd(skill2Dir, { name: 'skill-two', description: 'Second skill' }, 'Instructions 2');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(2);
+            expect(result.errors).toHaveLength(0);
+            const names = result.skills.map(s => s.name).sort();
+            expect(names).toEqual(['skill-one', 'skill-two']);
+        });
+        it('should ignore non-directory entries', async () => {
+            // Create a file instead of directory
+            fs.writeFileSync(path.join(testDir, 'not-a-dir.yaml'), 'name: test');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(0);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should load async skill correctly', async () => {
+            const skillDir = path.join(testDir, 'async-skill');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, {
+                name: 'async-skill',
+                description: 'An async skill',
+                execution_mode: 'async',
+            }, 'Long-running task instructions');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.skills[0].execution_mode).toBe('async');
+        });
+    });
+    describe('content handling', () => {
+        it('should include content in skill object', async () => {
+            const skillDir = path.join(testDir, 'content-skill');
+            fs.ensureDirSync(skillDir);
+            const mdContent = '# Content Skill\n\nThis is the instruction content.';
+            createSkillMd(skillDir, { name: 'content-skill', description: 'Test' }, mdContent);
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.skills[0].content).toBe(mdContent);
+        });
+        it('should handle empty content after frontmatter', async () => {
+            const skillDir = path.join(testDir, 'empty-content');
+            fs.ensureDirSync(skillDir);
+            createSkillMd(skillDir, { name: 'empty-content', description: 'Test' }, '');
+            const result = await loader.scan();
+            expect(result.skills).toHaveLength(1);
+            expect(result.skills[0].content).toBe('');
+        });
+    });
+});