morpheus-cli 0.9.5 → 0.9.6

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)')

package/dist/runtime/skills/tool.js

@@ -1,229 +1,62 @@
 /**
- * Skill Tools - skill_execute (sync) and skill_delegate (async)
+ * Skill Tool — load_skill
+ *
+ * Oracle uses this tool to load skill content into context on-demand.
+ * Replaces the old skill_execute/skill_delegate + Keymaker pattern.
  */
 import { tool } from "@langchain/core/tools";
 import { z } from "zod";
-import { TaskRepository } from "../tasks/repository.js";
-import { TaskRequestContext } from "../tasks/context.js";
-import { DisplayManager } from "../display.js";
 import { SkillRegistry } from "./registry.js";
-import { executeKeymakerTask } from "../keymaker.js";
 import { AuditRepository } from "../audit/repository.js";
-// ============================================================================
-// skill_execute - Synchronous execution
-// ============================================================================
-/**
- * Generates the skill_execute tool description dynamically with sync skills.
- */
-export function getSkillExecuteDescription() {
-    const registry = SkillRegistry.getInstance();
-    const syncSkills = registry.getEnabled().filter((s) => s.execution_mode === 'sync');
-    const skillList = syncSkills.length > 0
-        ? syncSkills.map(s => `- ${s.name}: ${s.description}`).join('\n')
-        : '(no sync skills enabled)';
-    return `Execute a skill synchronously using Keymaker. The result is returned immediately.
-
-Keymaker has access to ALL tools (filesystem, shell, git, MCP, browser, etc.) and will execute the skill instructions.
-
-Available sync skills:
-${skillList}
-
-Use this for skills that need immediate results in the conversation.`;
-}
-/**
- * Tool that Oracle uses to execute skills synchronously via Keymaker.
- * Result is returned directly to Oracle for inclusion in the response.
- */
-export const SkillExecuteTool = tool(async ({ skillName, objective }) => {
-    const display = DisplayManager.getInstance();
-    const registry = SkillRegistry.getInstance();
-    // Validate skill exists and is enabled
-    const skill = registry.get(skillName);
-    if (!skill) {
-        const available = registry.getEnabled().map(s => s.name).join(', ');
-        return `Error: Skill "${skillName}" not found. Available skills: ${available || 'none'}`;
-    }
-    if (!skill.enabled) {
-        return `Error: Skill "${skillName}" is disabled.`;
-    }
-    if (skill.execution_mode === 'async') {
-        return `Error: Skill "${skillName}" is async-only. Use skill_delegate instead.`;
-    }
-    display.log(`Executing skill "${skillName}" synchronously...`, {
-        source: "SkillExecuteTool",
-        level: "info",
-    });
-    try {
-        const ctx = TaskRequestContext.get();
-        const sessionId = ctx?.session_id ?? "default";
-        const taskContext = {
-            origin_channel: ctx?.origin_channel ?? "api",
-            session_id: sessionId,
-            origin_message_id: ctx?.origin_message_id,
-            origin_user_id: ctx?.origin_user_id,
-        };
-        // Execute Keymaker directly (synchronous)
-        const result = await executeKeymakerTask(skillName, objective, taskContext);
-        display.log(`Skill "${skillName}" completed successfully.`, {
-            source: "SkillExecuteTool",
-            level: "info",
-        });
-        // Emit audit events for sync execution (async path is handled by TaskWorker)
-        const audit = AuditRepository.getInstance();
-        if (result.usage && (result.usage.inputTokens > 0 || result.usage.outputTokens > 0)) {
-            audit.insert({
-                session_id: sessionId,
-                event_type: 'llm_call',
-                agent: 'keymaker',
-                provider: result.usage.provider,
-                model: result.usage.model,
-                input_tokens: result.usage.inputTokens,
-                output_tokens: result.usage.outputTokens,
-                duration_ms: result.usage.durationMs,
-                status: 'success',
-                metadata: { step_count: result.usage.stepCount },
-            });
-        }
-        audit.insert({
-            session_id: sessionId,
-            event_type: 'skill_executed',
-            agent: 'keymaker',
-            tool_name: skillName,
-            duration_ms: result.usage?.durationMs,
-            status: 'success',
-        });
-        return result;
-    }
-    catch (err) {
-        display.log(`Skill execution error: ${err.message}`, {
-            source: "SkillExecuteTool",
-            level: "error",
-        });
-        return `Skill execution failed: ${err.message}`;
-    }
-}, {
-    name: "skill_execute",
-    description: getSkillExecuteDescription(),
-    schema: z.object({
-        skillName: z.string().describe("Exact name of the sync skill to use"),
-        objective: z.string().describe("Clear description of what to accomplish"),
-    }),
-});
-// ============================================================================
-// skill_delegate - Asynchronous execution (background task)
-// ============================================================================
-/**
- * Generates the skill_delegate tool description dynamically with async skills.
- */
-export function getSkillDelegateDescription() {
-    const registry = SkillRegistry.getInstance();
-    const asyncSkills = registry.getEnabled().filter((s) => s.execution_mode === 'async');
-    const skillList = asyncSkills.length > 0
-        ? asyncSkills.map(s => `- ${s.name}: ${s.description}`).join('\n')
-        : '(no async skills enabled)';
-    return `Delegate a task to Keymaker as a background job. You will be notified when complete.
-
-Keymaker has access to ALL tools (filesystem, shell, git, MCP, browser, etc.) and will execute the skill instructions.
-
-Available async skills:
-${skillList}
-
-Use this for long-running skills like builds, deployments, or batch processing.`;
-}
+import { TaskRequestContext } from "../tasks/context.js";
 /**
- * Tool that Oracle uses to delegate tasks to Keymaker via async task queue.
- * Keymaker will execute the skill instructions in background.
+ * Creates the load_skill tool for Oracle.
+ * Returns skill content as context — Oracle handles execution with its own tools.
  */
-export const SkillDelegateTool = tool(async ({ skillName, objective }) => {
-    try {
-        const display = DisplayManager.getInstance();
+export function createLoadSkillTool() {
+    return tool(async ({ skillName }) => {
         const registry = SkillRegistry.getInstance();
-        // Validate skill exists and is enabled
         const skill = registry.get(skillName);
         if (!skill) {
             const available = registry.getEnabled().map(s => s.name).join(', ');
-            return `Error: Skill "${skillName}" not found. Available skills: ${available || 'none'}`;
+            return `Skill '${skillName}' not found. Available skills: ${available || 'none'}`;
         }
         if (!skill.enabled) {
-            return `Error: Skill "${skillName}" is disabled.`;
-        }
-        if (skill.execution_mode !== 'async') {
-            return `Error: Skill "${skillName}" is sync. Use skill_execute instead for immediate results.`;
+            return `Skill '${skillName}' is disabled.`;
         }
-        // Check for duplicate delegation
-        const existingAck = TaskRequestContext.findDuplicateDelegation("keymaker", `${skillName}:${objective}`);
-        if (existingAck) {
-            display.log(`Keymaker delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
-                source: "SkillDelegateTool",
-                level: "info",
-            });
-            return `Task ${existingAck.task_id} already queued for Keymaker (${skillName}) execution.`;
-        }
-        if (!TaskRequestContext.canEnqueueDelegation()) {
-            display.log(`Keymaker delegation blocked by per-turn limit.`, {
-                source: "SkillDelegateTool",
-                level: "warning",
+        // Emit audit event
+        try {
+            const ctx = TaskRequestContext.get();
+            const sessionId = ctx?.session_id ?? 'default';
+            AuditRepository.getInstance().insert({
+                session_id: sessionId,
+                event_type: 'skill_loaded',
+                agent: 'oracle',
+                tool_name: skillName,
+                status: 'success',
             });
-            return "Delegation limit reached for this user turn. Wait for current tasks to complete.";
         }
-        const ctx = TaskRequestContext.get();
-        const repository = TaskRepository.getInstance();
-        // Store skill name in context as JSON
-        const taskContext = JSON.stringify({ skill: skillName });
-        const created = repository.createTask({
-            agent: "keymaker",
-            input: objective,
-            context: taskContext,
-            origin_channel: ctx?.origin_channel ?? "api",
-            session_id: ctx?.session_id ?? "default",
-            origin_message_id: ctx?.origin_message_id ?? null,
-            origin_user_id: ctx?.origin_user_id ?? null,
-            max_attempts: 3,
-        });
-        TaskRequestContext.setDelegationAck({
-            task_id: created.id,
-            agent: "keymaker",
-            task: `${skillName}:${objective}`,
-        });
-        display.log(`Keymaker task created: ${created.id} (skill: ${skillName})`, {
-            source: "SkillDelegateTool",
-            level: "info",
-            meta: {
-                agent: created.agent,
-                skill: skillName,
-                origin_channel: created.origin_channel,
-                session_id: created.session_id,
-                input: created.input,
-            }
-        });
-        return `Task ${created.id} queued for Keymaker (skill: ${skillName}). You will be notified when complete.`;
-    }
-    catch (err) {
-        const display = DisplayManager.getInstance();
-        display.log(`SkillDelegateTool error: ${err.message}`, {
-            source: "SkillDelegateTool",
-            level: "error",
-        });
-        return `Keymaker task enqueue failed: ${err.message}`;
-    }
-}, {
-    name: "skill_delegate",
-    description: getSkillDelegateDescription(),
-    schema: z.object({
-        skillName: z.string().describe("Exact name of the async skill to use"),
-        objective: z.string().describe("Clear description of what Keymaker should accomplish"),
-    }),
-});
-// ============================================================================
-// Utility functions
-// ============================================================================
+        catch { /* non-critical */ }
+        return `Loaded skill: ${skillName}\n\n${skill.content}`;
+    }, {
+        name: "load_skill",
+        description: buildLoadSkillDescription(),
+        schema: z.object({
+            skillName: z.string().describe("The name of the skill to load"),
+        }),
+    });
+}
 /**
- * Updates both skill tool descriptions with current skill list.
- * Should be called after skills are loaded/reloaded.
+ * Builds the load_skill tool description with available skills.
  */
-export function updateSkillToolDescriptions() {
-    SkillExecuteTool.description = getSkillExecuteDescription();
-    SkillDelegateTool.description = getSkillDelegateDescription();
+function buildLoadSkillDescription() {
+    const registry = SkillRegistry.getInstance();
+    const enabled = registry.getEnabled();
+    const skillList = enabled.length > 0
+        ? enabled.map(s => `- ${s.name}: ${s.description}`).join('\n')
+        : '(no skills available)';
+    return `Load a skill's instructions into your context. After loading, follow the instructions to handle the request using your existing tools or delegate to Agents.
+
+Available skills:
+${skillList}`;
 }
-// Backwards compatibility alias
-export const updateSkillDelegateDescription = updateSkillToolDescriptions;