morpheus-cli 0.7.2 → 0.7.4

package/dist/runtime/skills/tool.js

@@ -0,0 +1,204 @@
+/**
+ * Skill Tools - skill_execute (sync) and skill_delegate (async)
+ */
+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";
+// ============================================================================
+// 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",
+        });
+        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.`;
+}
+/**
+ * Tool that Oracle uses to delegate tasks to Keymaker via async task queue.
+ * Keymaker will execute the skill instructions in background.
+ */
+export const SkillDelegateTool = tool(async ({ skillName, objective }) => {
+    try {
+        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 sync. Use skill_execute instead for immediate results.`;
+        }
+        // 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",
+            });
+            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
+// ============================================================================
+/**
+ * Updates both skill tool descriptions with current skill list.
+ * Should be called after skills are loaded/reloaded.
+ */
+export function updateSkillToolDescriptions() {
+    SkillExecuteTool.description = getSkillExecuteDescription();
+    SkillDelegateTool.description = getSkillDelegateDescription();
+}
+// Backwards compatibility alias
+export const updateSkillDelegateDescription = updateSkillToolDescriptions;

package/dist/runtime/skills/types.js

@@ -0,0 +1,7 @@
+/**
+ * Skills System Type Definitions
+ *
+ * Skills are user-defined behavioral extensions loaded from ~/.morpheus/skills/
+ * Each skill is a SKILL.md file with YAML frontmatter containing metadata.
+ */
+export {};

package/dist/runtime/tasks/context.js

@@ -27,6 +27,22 @@ export class TaskRequestContext {
     static canEnqueueDelegation() {
         return this.getDelegationAcks().length < this.MAX_DELEGATIONS_PER_TURN;
     }
+    /**
+     * Record that a delegation tool executed synchronously (inline).
+     * Oracle uses this to know that the tool call was NOT an async enqueue.
+     */
+    static incrementSyncDelegation() {
+        const current = storage.getStore();
+        if (!current)
+            return;
+        current.sync_delegation_count = (current.sync_delegation_count ?? 0) + 1;
+    }
+    /**
+     * Returns the number of delegation tools that executed synchronously this turn.
+     */
+    static getSyncDelegationCount() {
+        return storage.getStore()?.sync_delegation_count ?? 0;
+    }
     static findDuplicateDelegation(agent, task) {
         const acks = this.getDelegationAcks();
         if (acks.length === 0)

package/dist/runtime/tasks/worker.js

@@ -3,6 +3,7 @@ import { DisplayManager } from '../display.js';
 import { Apoc } from '../apoc.js';
 import { Neo } from '../neo.js';
 import { Trinity } from '../trinity.js';
+import { executeKeymakerTask } from '../keymaker.js';
 import { TaskRepository } from './repository.js';
 export class TaskWorker {
     workerId;
@@ -71,6 +72,27 @@ export class TaskWorker {
                     output = await trinity.execute(task.input, task.context ?? undefined, task.session_id);
                     break;
                 }
+                case 'keymaker': {
+                    // Parse skill name from context JSON
+                    let skillName = 'unknown';
+                    if (task.context) {
+                        try {
+                            const parsed = JSON.parse(task.context);
+                            skillName = parsed.skill || 'unknown';
+                        }
+                        catch {
+                            // context is not JSON, use as skill name directly for backwards compat
+                            skillName = task.context;
+                        }
+                    }
+                    output = await executeKeymakerTask(skillName, task.input, {
+                        origin_channel: task.origin_channel,
+                        session_id: task.session_id,
+                        origin_message_id: task.origin_message_id ?? undefined,
+                        origin_user_id: task.origin_user_id ?? undefined,
+                    });
+                    break;
+                }
                 default: {
                     throw new Error(`Unknown task agent: ${task.agent}`);
                 }

package/dist/runtime/tools/apoc-tool.js

@@ -4,6 +4,15 @@ import { TaskRepository } from "../tasks/repository.js";
 import { TaskRequestContext } from "../tasks/context.js";
 import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
 import { DisplayManager } from "../display.js";
+import { ConfigManager } from "../../config/manager.js";
+import { Apoc } from "../apoc.js";
+/**
+ * Returns true when Apoc is configured to execute synchronously (inline).
+ */
+function isApocSync() {
+    const config = ConfigManager.getInstance().get();
+    return config.apoc?.execution_mode === 'sync';
+}
 /**
  * Tool that Oracle uses to delegate devtools tasks to Apoc.
  * Oracle should call this whenever the user requests operations like:
@@ -25,6 +34,24 @@ export const ApocDelegateTool = tool(async ({ task, context }) => {
             });
             return compositeDelegationError();
         }
+        // ── Sync mode: execute inline and return result directly ──
+        if (isApocSync()) {
+            display.log(`Apoc executing synchronously: ${task.slice(0, 80)}...`, {
+                source: "ApocDelegateTool",
+                level: "info",
+            });
+            const ctx = TaskRequestContext.get();
+            const sessionId = ctx?.session_id ?? "default";
+            const apoc = Apoc.getInstance();
+            const result = await apoc.execute(task, context, sessionId);
+            TaskRequestContext.incrementSyncDelegation();
+            display.log(`Apoc sync execution completed.`, {
+                source: "ApocDelegateTool",
+                level: "info",
+            });
+            return result;
+        }
+        // ── Async mode (default): create background task ──
         const existingAck = TaskRequestContext.findDuplicateDelegation("apoc", task);
         if (existingAck) {
             display.log(`Apoc delegation deduplicated. Reusing task ${existingAck.task_id}.`, {
@@ -72,7 +99,7 @@ export const ApocDelegateTool = tool(async ({ task, context }) => {
     }
 }, {
     name: "apoc_delegate",
-    description: `Delegate a devtools task to Apoc, the specialized development subagent, asynchronously.
+    description: `Delegate a devtools task to Apoc, the specialized development subagent.
 
 This tool enqueues a background task and returns an acknowledgement with task id.
 Do not expect final execution output in the same response.

package/dist/runtime/tools/morpheus-tools.js

@@ -29,16 +29,19 @@ const CONFIG_TO_ENV_MAP = {
     'neo.model': ['MORPHEUS_NEO_MODEL'],
     'neo.temperature': ['MORPHEUS_NEO_TEMPERATURE'],
     'neo.api_key': ['MORPHEUS_NEO_API_KEY'],
+    'neo.execution_mode': ['MORPHEUS_NEO_EXECUTION_MODE'],
     'apoc.provider': ['MORPHEUS_APOC_PROVIDER'],
     'apoc.model': ['MORPHEUS_APOC_MODEL'],
     'apoc.temperature': ['MORPHEUS_APOC_TEMPERATURE'],
     'apoc.api_key': ['MORPHEUS_APOC_API_KEY'],
     'apoc.working_dir': ['MORPHEUS_APOC_WORKING_DIR'],
     'apoc.timeout_ms': ['MORPHEUS_APOC_TIMEOUT_MS'],
+    'apoc.execution_mode': ['MORPHEUS_APOC_EXECUTION_MODE'],
     'trinity.provider': ['MORPHEUS_TRINITY_PROVIDER'],
     'trinity.model': ['MORPHEUS_TRINITY_MODEL'],
     'trinity.temperature': ['MORPHEUS_TRINITY_TEMPERATURE'],
     'trinity.api_key': ['MORPHEUS_TRINITY_API_KEY'],
+    'trinity.execution_mode': ['MORPHEUS_TRINITY_EXECUTION_MODE'],
     'audio.provider': ['MORPHEUS_AUDIO_PROVIDER'],
     'audio.model': ['MORPHEUS_AUDIO_MODEL'],
     'audio.apiKey': ['MORPHEUS_AUDIO_API_KEY'],

package/dist/runtime/tools/neo-tool.js

@@ -4,6 +4,8 @@ import { TaskRepository } from "../tasks/repository.js";
 import { TaskRequestContext } from "../tasks/context.js";
 import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
 import { DisplayManager } from "../display.js";
+import { ConfigManager } from "../../config/manager.js";
+import { Neo } from "../neo.js";
 const NEO_BUILTIN_CAPABILITIES = `
 Neo built-in capabilities (always available — no MCP required):
 • Config: morpheus_config_query, morpheus_config_update — read/write Morpheus configuration (LLM, channels, UI, etc.)
@@ -39,6 +41,13 @@ function buildCatalogSection(mcpTools) {
     }
     return `\n\nRuntime MCP tools:\n${lines.join("\n")}`;
 }
+/**
+ * Returns true when Neo is configured to execute synchronously (inline).
+ */
+function isNeoSync() {
+    const config = ConfigManager.getInstance().get();
+    return config.neo?.execution_mode === 'sync';
+}
 export function updateNeoDelegateToolDescription(tools) {
     const full = `${NEO_BASE_DESCRIPTION}${buildCatalogSection(tools)}`;
     NeoDelegateTool.description = full;
@@ -53,6 +62,29 @@ export const NeoDelegateTool = tool(async ({ task, context }) => {
             });
             return compositeDelegationError();
         }
+        // ── Sync mode: execute inline and return result directly ──
+        if (isNeoSync()) {
+            display.log(`Neo executing synchronously: ${task.slice(0, 80)}...`, {
+                source: "NeoDelegateTool",
+                level: "info",
+            });
+            const ctx = TaskRequestContext.get();
+            const sessionId = ctx?.session_id ?? "default";
+            const neo = Neo.getInstance();
+            const result = await neo.execute(task, context, sessionId, {
+                origin_channel: ctx?.origin_channel ?? "api",
+                session_id: sessionId,
+                origin_message_id: ctx?.origin_message_id,
+                origin_user_id: ctx?.origin_user_id,
+            });
+            TaskRequestContext.incrementSyncDelegation();
+            display.log(`Neo sync execution completed.`, {
+                source: "NeoDelegateTool",
+                level: "info",
+            });
+            return result;
+        }
+        // ── Async mode (default): create background task ──
         const existingAck = TaskRequestContext.findDuplicateDelegation("neo", task);
         if (existingAck) {
             display.log(`Neo delegation deduplicated. Reusing task ${existingAck.task_id}.`, {

package/dist/runtime/tools/trinity-tool.js

@@ -4,6 +4,8 @@ import { TaskRepository } from "../tasks/repository.js";
 import { TaskRequestContext } from "../tasks/context.js";
 import { compositeDelegationError, isLikelyCompositeDelegationTask } from "./delegation-guard.js";
 import { DisplayManager } from "../display.js";
+import { ConfigManager } from "../../config/manager.js";
+import { Trinity } from "../trinity.js";
 const TRINITY_BASE_DESCRIPTION = `Delegate a database task to Trinity, the specialized database subagent, asynchronously.
 
 This tool enqueues a background task and returns an acknowledgement with task id.
@@ -30,6 +32,13 @@ export function updateTrinityDelegateToolDescription(databases) {
     const full = `${TRINITY_BASE_DESCRIPTION}${buildDatabaseCatalog(databases)}`;
     TrinityDelegateTool.description = full;
 }
+/**
+ * Returns true when Trinity is configured to execute synchronously (inline).
+ */
+function isTrinitySync() {
+    const config = ConfigManager.getInstance().get();
+    return config.trinity?.execution_mode === 'sync';
+}
 export const TrinityDelegateTool = tool(async ({ task, context }) => {
     try {
         const display = DisplayManager.getInstance();
@@ -40,6 +49,24 @@ export const TrinityDelegateTool = tool(async ({ task, context }) => {
             });
             return compositeDelegationError();
         }
+        // ── Sync mode: execute inline and return result directly ──
+        if (isTrinitySync()) {
+            display.log(`Trinity executing synchronously: ${task.slice(0, 80)}...`, {
+                source: 'TrinityDelegateTool',
+                level: 'info',
+            });
+            const ctx = TaskRequestContext.get();
+            const sessionId = ctx?.session_id ?? 'default';
+            const trinity = Trinity.getInstance();
+            const result = await trinity.execute(task, context, sessionId);
+            TaskRequestContext.incrementSyncDelegation();
+            display.log(`Trinity sync execution completed.`, {
+                source: 'TrinityDelegateTool',
+                level: 'info',
+            });
+            return result;
+        }
+        // ── Async mode (default): create background task ──
         const existingAck = TaskRequestContext.findDuplicateDelegation('trinit', task);
         if (existingAck) {
             display.log(`Trinity delegation deduplicated. Reusing task ${existingAck.task_id}.`, {

package/dist/types/config.js

@@ -51,17 +51,20 @@ export const DEFAULT_CONFIG = {
         temperature: 0.2,
         timeout_ms: 30000,
         personality: 'pragmatic_dev',
+        execution_mode: 'async',
     },
     neo: {
         provider: 'openai',
         model: 'gpt-4',
         temperature: 0.2,
         personality: 'analytical_engineer',
+        execution_mode: 'async',
     },
     trinity: {
         provider: 'openai',
         model: 'gpt-4',
         temperature: 0.2,
         personality: 'data_specialist',
+        execution_mode: 'async',
     }
 };