morpheus-cli 0.7.3 → 0.7.5

package/dist/config/manager.js

@@ -169,6 +169,7 @@ export class ConfigManager {
                 working_dir: resolveString('MORPHEUS_APOC_WORKING_DIR', config.apoc.working_dir, process.cwd()),
                 timeout_ms: config.apoc.timeout_ms !== undefined ? resolveNumeric('MORPHEUS_APOC_TIMEOUT_MS', config.apoc.timeout_ms, 30_000) : 30_000,
                 personality: resolveString('MORPHEUS_APOC_PERSONALITY', config.apoc.personality, 'pragmatic_dev'),
+                execution_mode: resolveString('MORPHEUS_APOC_EXECUTION_MODE', config.apoc.execution_mode, 'async'),
             };
         }
         // Apply precedence to Neo config
@@ -209,6 +210,7 @@ export class ConfigManager {
                 base_url: neoBaseUrl || undefined,
                 context_window: resolveOptionalNumeric('MORPHEUS_NEO_CONTEXT_WINDOW', config.neo?.context_window, neoContextWindowFallback),
                 personality: resolveString('MORPHEUS_NEO_PERSONALITY', config.neo?.personality, 'analytical_engineer'),
+                execution_mode: resolveString('MORPHEUS_NEO_EXECUTION_MODE', config.neo?.execution_mode, 'async'),
             };
         }
         // Apply precedence to Trinity config
@@ -233,6 +235,7 @@ export class ConfigManager {
                 base_url: config.trinity?.base_url || config.llm.base_url,
                 context_window: resolveOptionalNumeric('MORPHEUS_TRINITY_CONTEXT_WINDOW', config.trinity?.context_window, trinityContextWindowFallback),
                 personality: resolveString('MORPHEUS_TRINITY_PERSONALITY', config.trinity?.personality, 'data_specialist'),
+                execution_mode: resolveString('MORPHEUS_TRINITY_EXECUTION_MODE', config.trinity?.execution_mode, 'async'),
             };
         }
         // Apply precedence to audio config
@@ -297,6 +300,7 @@ export class ConfigManager {
             logging: loggingConfig,
             memory: memoryConfig,
             chronos: chronosConfig,
+            verbose_mode: resolveBoolean('MORPHEUS_VERBOSE_MODE', config.verbose_mode, true),
         };
     }
     get() {

package/dist/config/schemas.js

@@ -25,9 +25,14 @@ export const SatiConfigSchema = LLMConfigSchema.extend({
 export const ApocConfigSchema = LLMConfigSchema.extend({
     working_dir: z.string().optional(),
     timeout_ms: z.number().int().positive().optional(),
+    execution_mode: z.enum(['sync', 'async']).default('async'),
+});
+export const NeoConfigSchema = LLMConfigSchema.extend({
+    execution_mode: z.enum(['sync', 'async']).default('async'),
+});
+export const TrinityConfigSchema = LLMConfigSchema.extend({
+    execution_mode: z.enum(['sync', 'async']).default('async'),
 });
-export const NeoConfigSchema = LLMConfigSchema;
-export const TrinityConfigSchema = LLMConfigSchema;
 export const KeymakerConfigSchema = LLMConfigSchema.extend({
     skills_dir: z.string().optional(),
 });
@@ -62,6 +67,7 @@ export const ConfigSchema = z.object({
         }).default(DEFAULT_CONFIG.runtime?.async_tasks ?? { enabled: true }),
     }).optional(),
     chronos: ChronosConfigSchema.optional(),
+    verbose_mode: z.boolean().default(true),
     channels: z.object({
         telegram: z.object({
             enabled: z.boolean().default(false),

package/dist/http/routers/skills.js

@@ -1,6 +1,78 @@
 import { Router } from 'express';
+import multer from 'multer';
+import extract from 'extract-zip';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
 import { SkillRegistry, updateSkillDelegateDescription } from '../../runtime/skills/index.js';
 import { DisplayManager } from '../../runtime/display.js';
+import { PATHS } from '../../config/paths.js';
+import { SkillMetadataSchema } from '../../runtime/skills/schema.js';
+// Multer config for ZIP uploads
+const upload = multer({
+    storage: multer.memoryStorage(),
+    limits: { fileSize: 10 * 1024 * 1024 }, // 10MB max
+    fileFilter: (_req, file, cb) => {
+        if (file.mimetype === 'application/zip' || file.mimetype === 'application/x-zip-compressed' || file.originalname.endsWith('.zip')) {
+            cb(null, true);
+        }
+        else {
+            cb(new Error('Only ZIP files are allowed'));
+        }
+    },
+});
+// YAML frontmatter regex
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/**
+ * Simple YAML frontmatter parser
+ */
+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;
+        if (trimmed.startsWith('- ') && currentKey && currentArray !== null) {
+            currentArray.push(trimmed.slice(2).trim().replace(/^["']|["']$/g, ''));
+            continue;
+        }
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+            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 === '') {
+                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 {
+                result[key] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+    }
+    if (currentKey && currentArray !== null && currentArray.length > 0) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
 /**
  * Create the skills API router
  *
@@ -8,6 +80,7 @@ import { DisplayManager } from '../../runtime/display.js';
  * - GET /api/skills - List all skills
  * - GET /api/skills/:name - Get single skill with content
  * - POST /api/skills/reload - Reload skills from filesystem
+ * - POST /api/skills/upload - Upload a skill ZIP
  * - POST /api/skills/:name/enable - Enable a skill
  * - POST /api/skills/:name/disable - Disable a skill
  */
@@ -65,6 +138,97 @@ export function createSkillsRouter() {
             res.status(500).json({ error: err.message });
         }
     });
+    // POST /api/skills/upload - Upload a skill ZIP
+    // Must be before /:name routes
+    router.post('/upload', upload.single('file'), async (req, res) => {
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'morpheus-skill-'));
+        try {
+            if (!req.file) {
+                return res.status(400).json({ error: 'No file uploaded' });
+            }
+            const zipPath = path.join(tempDir, 'skill.zip');
+            const extractDir = path.join(tempDir, 'extracted');
+            // Write buffer to temp file
+            await fs.writeFile(zipPath, req.file.buffer);
+            // Extract ZIP
+            await extract(zipPath, { dir: extractDir });
+            // Find root entries
+            const entries = await fs.readdir(extractDir, { withFileTypes: true });
+            const folders = entries.filter(e => e.isDirectory());
+            const files = entries.filter(e => e.isFile());
+            // Validate: exactly one folder at root, no loose files
+            if (folders.length !== 1 || files.length > 0) {
+                return res.status(400).json({
+                    error: 'Invalid ZIP structure',
+                    details: 'ZIP must contain exactly one folder at root level (no loose files)',
+                });
+            }
+            const skillFolderName = folders[0].name;
+            const skillFolderPath = path.join(extractDir, skillFolderName);
+            // Check for SKILL.md
+            const skillMdPath = path.join(skillFolderPath, 'SKILL.md');
+            if (!await fs.pathExists(skillMdPath)) {
+                return res.status(400).json({
+                    error: 'Missing SKILL.md',
+                    details: `Folder "${skillFolderName}" must contain a SKILL.md file`,
+                });
+            }
+            // Read and validate SKILL.md frontmatter
+            const skillMdContent = await fs.readFile(skillMdPath, 'utf-8');
+            const match = skillMdContent.match(FRONTMATTER_REGEX);
+            if (!match) {
+                return res.status(400).json({
+                    error: 'Invalid SKILL.md format',
+                    details: 'SKILL.md must have YAML frontmatter between --- delimiters',
+                });
+            }
+            const [, frontmatterYaml] = match;
+            const rawMetadata = parseFrontmatter(frontmatterYaml);
+            // Validate with Zod schema
+            const parseResult = SkillMetadataSchema.safeParse(rawMetadata);
+            if (!parseResult.success) {
+                const issues = parseResult.error.issues.map(i => `${i.path.join('.')}: ${i.message}`);
+                return res.status(400).json({
+                    error: 'Invalid skill metadata',
+                    details: issues.join('; '),
+                });
+            }
+            const metadata = parseResult.data;
+            // Check if skill already exists
+            const targetPath = path.join(PATHS.skills, metadata.name);
+            if (await fs.pathExists(targetPath)) {
+                return res.status(409).json({
+                    error: 'Skill already exists',
+                    details: `A skill named "${metadata.name}" already exists. Delete it first or choose a different name.`,
+                });
+            }
+            // Copy to skills directory
+            await fs.copy(skillFolderPath, targetPath);
+            // Reload skills
+            const registry = SkillRegistry.getInstance();
+            await registry.reload();
+            updateSkillDelegateDescription();
+            display.log(`Skill "${metadata.name}" uploaded successfully`, { source: 'SkillsAPI' });
+            res.json({
+                success: true,
+                skill: {
+                    name: metadata.name,
+                    description: metadata.description,
+                    version: metadata.version,
+                    author: metadata.author,
+                    path: targetPath,
+                },
+            });
+        }
+        catch (err) {
+            display.log(`Skill upload error: ${err.message}`, { source: 'SkillsAPI', level: 'error' });
+            res.status(500).json({ error: err.message });
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.remove(tempDir).catch(() => { });
+        }
+    });
     // GET /api/skills/:name - Get single skill with content
     router.get('/:name', (req, res) => {
         try {

package/dist/runtime/oracle.js

@@ -341,9 +341,11 @@ Use it to inform your response and tool selection (if needed), but do not assume
                 origin_user_id: taskContext?.origin_user_id,
             };
             let contextDelegationAcks = [];
+            let syncDelegationCount = 0;
             const response = await TaskRequestContext.run(invokeContext, async () => {
                 const agentResponse = await this.provider.invoke({ messages });
                 contextDelegationAcks = TaskRequestContext.getDelegationAcks();
+                syncDelegationCount = TaskRequestContext.getSyncDelegationCount();
                 return agentResponse;
             });
             // Identify new messages generated during the interaction
@@ -364,13 +366,17 @@ Use it to inform your response and tool selection (if needed), but do not assume
             const toolDelegationAcks = this.extractDelegationAcksFromMessages(newGeneratedMessages);
             const hadDelegationToolCall = this.hasDelegationToolCall(newGeneratedMessages);
             const hadChronosToolCall = this.hasChronosToolCall(newGeneratedMessages);
+            // When all delegation tool calls ran synchronously, there are no task IDs to validate.
+            // Treat as a normal (non-delegation) response so the inline result flows through.
+            const allDelegationsSyncInline = hadDelegationToolCall && syncDelegationCount > 0
+                && contextDelegationAcks.length === 0;
             const mergedDelegationAcks = [
                 ...contextDelegationAcks.map((ack) => ({ task_id: ack.task_id, agent: ack.agent })),
                 ...toolDelegationAcks,
             ];
             const validDelegationAcks = this.validateDelegationAcks(mergedDelegationAcks, message);
             if (mergedDelegationAcks.length > 0) {
-                this.display.log(`Delegation trace: context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, valid=${validDelegationAcks.length}`, { source: "Oracle", level: "info" });
+                this.display.log(`Delegation trace: context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, valid=${validDelegationAcks.length}, sync_inline=${syncDelegationCount}`, { source: "Oracle", level: "info" });
             }
             const delegatedThisTurn = validDelegationAcks.length > 0;
             let blockedSyntheticDelegationAck = false;
@@ -392,7 +398,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
                 // returned to the caller (Telegram / UI) immediately after this point.
                 this.taskRepository.markAckSent(validDelegationAcks.map(a => a.task_id));
             }
-            else if (mergedDelegationAcks.length > 0 || hadDelegationToolCall) {
+            else if (!allDelegationsSyncInline && (mergedDelegationAcks.length > 0 || hadDelegationToolCall)) {
                 this.display.log(`Delegation attempted but no valid task id was confirmed (context=${contextDelegationAcks.length}, tool_messages=${toolDelegationAcks.length}, had_tool_call=${hadDelegationToolCall}).`, { source: "Oracle", level: "error" });
                 // Delegation was attempted but no valid task id could be confirmed in DB.
                 responseContent = this.buildDelegationFailureResponse();

package/dist/runtime/providers/factory.js

@@ -6,6 +6,11 @@ import { ProviderError } from "../errors.js";
 import { createAgent, createMiddleware } from "langchain";
 import { DisplayManager } from "../display.js";
 import { getUsableApiKey } from "../trinity-crypto.js";
+import { ConfigManager } from "../../config/manager.js";
+import { TaskRequestContext } from "../tasks/context.js";
+import { ChannelRegistry } from "../../channels/registry.js";
+/** Channels that should NOT receive verbose tool notifications */
+const SILENT_CHANNELS = new Set(['api', 'ui']);
 export class ProviderFactory {
     static buildMonitoringMiddleware() {
         const display = DisplayManager.getInstance();
@@ -14,6 +19,15 @@ export class ProviderFactory {
             wrapToolCall: (request, handler) => {
                 display.log(`Executing tool: ${request.toolCall.name}`, { level: "warning", source: 'ConstructLoad' });
                 display.log(`Arguments: ${JSON.stringify(request.toolCall.args)}`, { level: "info", source: 'ConstructLoad' });
+                // Verbose mode: notify originating channel about which tool is running
+                const verboseEnabled = ConfigManager.getInstance().get().verbose_mode !== false;
+                if (verboseEnabled) {
+                    const ctx = TaskRequestContext.get();
+                    if (ctx?.origin_channel && ctx.origin_user_id && !SILENT_CHANNELS.has(ctx.origin_channel)) {
+                        ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, `🔧 executing: ${request.toolCall.name}`)
+                            .catch(() => { });
+                    }
+                }
                 try {
                     const result = handler(request);
                     display.log(`Tool completed successfully. Result: ${JSON.stringify(result)}`, { level: "info", source: 'ConstructLoad' });

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/tools/apoc-tool.js

@@ -4,6 +4,16 @@ 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";
+import { ChannelRegistry } from "../../channels/registry.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 +35,29 @@ 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";
+            // Notify originating channel that the agent is working
+            if (ctx?.origin_channel && ctx.origin_user_id && ctx.origin_channel !== 'api' && ctx.origin_channel !== 'ui') {
+                ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, '🧑‍🔬 Apoc is executing your request...')
+                    .catch(() => { });
+            }
+            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 +105,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,20 +29,24 @@ 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'],
     'audio.maxDurationSeconds': ['MORPHEUS_AUDIO_MAX_DURATION'],
+    'verbose_mode': ['MORPHEUS_VERBOSE_MODE'],
 };
 /**
  * Checks if a config field is overridden by an environment variable.

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

@@ -4,6 +4,9 @@ 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";
+import { ChannelRegistry } from "../../channels/registry.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 +42,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 +63,34 @@ 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";
+            // Notify originating channel that the agent is working
+            if (ctx?.origin_channel && ctx.origin_user_id && ctx.origin_channel !== 'api' && ctx.origin_channel !== 'ui') {
+                ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, '🥷 Neo is executing your request...')
+                    .catch(() => { });
+            }
+            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,9 @@ 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";
+import { ChannelRegistry } from "../../channels/registry.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 +33,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 +50,29 @@ 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';
+            // Notify originating channel that the agent is working
+            if (ctx?.origin_channel && ctx.origin_user_id && ctx.origin_channel !== 'api' && ctx.origin_channel !== 'ui') {
+                ChannelRegistry.sendToUser(ctx.origin_channel, ctx.origin_user_id, '👩‍💻 Trinity is executing your request...')
+                    .catch(() => { });
+            }
+            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,21 @@ 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',
+    },
+    verbose_mode: true,
 };